Operator prediction in block representations using datasets
The integration of machine learning in CAD systems for predicting and assisting operator selection in 2D block representations addresses inefficiencies in existing CAD systems, enhancing ergonomics and design efficiency by automating operator addition in 3D modeled object design.
Patent Information
- Application Number
- JP2026078094
- Authority / Receiving Office
- JP · JP
- Patent Type
- Applications
- Current Assignee / Owner
- Priority Date
- 2025-05-07
- Filing Date
- 2026-05-07
- Publication Date
- 2026-11-19
AI Technical Summary
Existing CAD systems for designing 3D modeled objects require manual and inefficient searches for operators in 2D block representations, leading to suboptimal ergonomics and time consumption.
A computer-aided design method that simultaneously displays 3D and 2D representations, using machine learning to predict and assist in selecting operators based on a pre-trained function and dataset, allowing for ergonomic and efficient addition of operators through graphical interaction.
Enhances the ergonomics of operator selection and addition in CAD systems by providing assisted and fast operator selection, improving design efficiency and accuracy through machine learning-assisted proposals.
Smart Images

Figure 2026182825000001_ABST
Abstract
Description
[Technical Field]
[0001] This disclosure relates to the field of computer programs and systems, and more specifically to methods, devices, and programs relating to the prediction of one or more operators in a block representation of a manufactured product. [Background technology]
[0002] Numerous solutions, hardware, and software are available on the market for the design, engineering, and manufacturing of objects. CAD is an acronym for Computer-Aided Design, and refers, for example, to software solutions for designing objects. CAE is an acronym for Computer-Aided Engineering, and refers, for example, to software solutions for analyzing and simulating the physical behavior of future products. CAM is an acronym for Computer-Aided Manufacturing, and refers, for example, to software solutions for defining product manufacturing processes and resources. In such computer-aided design solutions, graphical user interfaces play a crucial role in the efficiency of the technology. These technologies can be incorporated into Product Lifecycle Management (PLM) solutions. PLM refers to an engineering strategy that helps companies share product data, apply common processes, and leverage enterprise knowledge for product development from concept to end of life across an extended enterprise concept. The PLM solutions offered by Dassault Systèmes (under the trademarks CATIA, SIMULIA, DELMIA, and ENOVIA) provide an engineering hub for organizing product engineering knowledge, a manufacturing hub for managing manufacturing engineering knowledge, and an enterprise hub that enables enterprise integration and connectivity to both the engineering and manufacturing hubs. Overall, the solution provides a common model that links products, processes, and resources to enable dynamic, knowledge-based product creation and decision support that drives optimized product definition, manufacturing readiness, production, and service.
[0003] As part of the CATIA software suite, xGenerative Design is a well-known web application that enables the design of 3D modeled objects representing manufactured products based on a 2D block representation of the 3D modeled object. In this application, the user can select output connectors in the 2D block representation and then manually search for new operators to add to the representation and connect to the selected output connectors via corresponding arcs, through a dedicated menu. Such manual searches involve typing text into a search bar and / or scrolling through a long, unordered list of operators.
[0004] The ergonomics of such solutions need to be improved. [Overview of the Initiative]
[0005] Accordingly, a computer implementation method is provided for designing 3D modeled objects representing products to be manufactured. The design method includes a computer system simultaneously displaying a 3D geometric representation of the 3D modeled object and a 2D block representation of the 3D modeled object. The 2D block representation includes block nodes, one or more input and output connectors on the corresponding block nodes, and an arc between the output connector of a first block node and the corresponding input connector of a second block node.
[0006] Each block node represents a corresponding operator in a given set of operators. Each operator in the given set of operators has a corresponding data identifier. Each operator in the given set of operators further has one or more inputs and outputs. Each input of each operator has a corresponding data identifier. Each output of each operator has a corresponding data identifier.
[0007] For at least one block node, the output of the corresponding operator represented by at least one block node is a corresponding set of one or more geometric objects. For at least one block node, the output of the operator has dynamic object cardinality, and at least one input of the operator has dynamic object cardinality. For at least one block node, the output of the operator has an object type, and optionally, the object type of the output of the operator is dynamic, in which case at least one input of the corresponding operator has a dynamic object type.
[0008] Each input connector represents the corresponding input of the corresponding operator, which is represented by the corresponding block node. Output connectors represent the output of the corresponding operator, which is represented by the corresponding block node.
[0009] Each arc represents a data flow from the output connector of the first block node to the corresponding input connector of the second block node.
[0010] The 2D block representation is configured such that the execution of the data flow represented by the arcs of the 2D block representation outputs a 3D shape representation.
[0011] The design method also involves a user graphically interacting with a 2D block representation to select one output connector from at least one block node. The block node of the selected output connector has a preceding block node.
[0012] The design method also involves obtaining a pre-trained machine learning function.
[0013] The design method further involves obtaining a dataset containing multiple data points. The dataset is based on multiple previously executed designs. Each data point contains a tuple and weights. The tuple contains a first operator represented by a first block node in one of the previously executed designs. The tuple further contains a second operator represented by a second block node in the design, the second block node having an output connector connected to the first block node. The tuple further contains a third operator represented by a third block node having a corresponding input connector connected to the corresponding output connector of the first block node. The tuple further contains the object type of the corresponding output connector of the first block node. The weights depend on the degree of instantiation of the tuple in the previously executed designs.
[0014] The design method further includes providing input data to a machine learning function. The input data includes at least the data identifier of the corresponding operator represented by the block node of the selected output connector, the data identifier of the selected output connector, and the object type of the selected output connector.
[0015] The design method further includes outputting predictions for one or more operators within a given set of operators, based on the results of a machine learning function and a dataset.
[0016] The design method is, - To display a graphical representation of at least one operator of the prediction using a computer system, - The user selects an operator from at least one of the prediction operators, -By computer systems, Adding a block node representing the selected operator to the 2D block representation, At the very least, updating the display of the 2D block representation by showing the added block nodes, adding an arc between the selected output connector and the corresponding connector of the added block node to the 2D block representation, thereby obtaining an updated 2D block representation; - updating the display of the 2D block representation by at least displaying the added arc; - executing a data flow represented by the arcs of the updated 2D block representation, thereby outputting an updated 3D shape representation; - displaying the updated 3D shape representation; is further included.
[0017] Such a design method forms an improved solution for designing a 3D modeled object representing a manufactured product, provides ergonomics for software applications that display a 2D block representation simultaneously with a 3D shape representation, and has all graphical user interaction features provided by this type of application, such as the ability for a user to interact graphically with the 2D block representation to select one or more of the displayed elements and perform edits. In addition, by using a trained machine learning function and a dataset based on a plurality of previously performed designs, the design method allows operators to be selected and added in an assisted and fast manner. In particular, the machine learning function may propose the most common operators, and the dataset may complement such proposals in view of the usage frequency of the operators. The dataset may also be user-dependent and provide user-specific proposals. Then, by executing the data flow, the design method enables an ergonomic update of the displayed 3D shape representation, which is ultimately potentially fed as-is to a manufacturing process that may be automatic.
[0018] The design method may include one or more of the following. - Outputting a prediction of one or more operators based on the machine learning function and the dataset comprises: o obtaining a first score for each given operator of a predetermined set of operators as a result of the machine learning function; Determining a second score for each given operator in a given set of operators, wherein the second score for a given operator represents the frequency of the corresponding tuple in the dataset, The first operator of the corresponding tuple is the corresponding operator represented by the block node of the selected output connector. The second operator of the corresponding tuple is the corresponding operator represented by the preceding block node of the block node of the selected output connector. The third operator of the corresponding tuple is a given operator, The object type of the corresponding tuple is the object type of the selected output connector, and This includes combining the first score and the second score to obtain a third score for each operator in a given set of operators. - The frequency of the corresponding tuple, represented by the second score, is the frequency of the corresponding tuple among all tuples in the dataset that have the same first operator, second operator, and object type as the corresponding tuple. - Operator O i The second score Score2(O i ) is given by the following equation,
[0019]
number
[0020]
number
[0021] is operator O i A set of operators that includes a predetermined set of operators, and each operator O j The first operator, the second operator, and the object type are O i The third operator of a tuple, which is the same as the one in the corresponding tuple, w j This is the third operator O jThis is the weight of the tuple it possesses. - The third score of each operator in a given set of operators is a convex combination of the operator's first and second scores. - The third score Score3(O) of operator O for a given set of operators is given by the following formula:
[0022]
number
[0023] oc and c' are numerical coefficients, oScore1(O) is the first score for operator O, oScore2(O) is the second score for operator O.
[0024] - The design method further involves the user selecting an operator from among at least one operator of prediction, and then increasing the weights of the corresponding tuples in the dataset by a predetermined number. The first operator of the corresponding tuple is the corresponding operator represented by the block node of the selected output connector, The second operator of the corresponding tuple is the corresponding operator represented by the preceding block node of the block node of the selected output connector, The third operator of the corresponding tuple is the selected operator, The object type of the corresponding tuple is the object type of the selected output connector. - The input data for the machine learning function further includes values that depend on the object cardinality of the selected output connector. - The value that depends on the object cardinality of the selected output connector is a binary value indicating whether the cardinality is 1 or greater than 1. - The machine learning function is a multilayer perceptron.
[0025] Further computer programs are provided that include instructions for executing the design method. When these instructions are executed by a processor, they cause the processor to execute the design method.
[0026] Furthermore, a computer-readable recording medium on which a computer program is stored is provided.
[0027] Furthermore, a system is provided that includes a processor coupled to memory and a graphical user interface, where the memory stores computer programs. [Brief explanation of the drawing]
[0028] Next, a non-limiting example will be explained with reference to the attached diagram.
[0029] [Figure 1] A flowchart illustrating an example of the design method is shown. [Figure 2] This shows an example of a device as a computer system. [Figure 3] This disclosure shows implementations of the methods, programs, and devices described herein. [Figure 4] This disclosure shows implementations of the methods, programs, and devices described herein. [Figure 5] This disclosure shows implementations of the methods, programs, and devices described herein. [Figure 6] This disclosure shows implementations of the methods, programs, and devices described herein. [Figure 7] Implementations of the methods, programs, and devices disclosed herein are shown. [Figure 8] This disclosure shows implementations of the methods, programs, and devices described herein. [Figure 9] Implementations of the methods, programs, and devices disclosed herein are shown. [Figure 10] Implementations of the methods, programs, and devices disclosed herein are shown. [Figure 11] Implementations of the methods, programs, and devices disclosed herein are shown. [Figure 12]Implementations of the methods, programs, and devices disclosed herein are shown. [Figure 13] Implementations of the methods, programs, and devices disclosed herein are shown. [Figure 14] Implementations of the methods, programs, and devices disclosed herein are shown. [Figure 15] Implementations of the methods, programs, and devices disclosed herein are shown. [Figure 16] Implementations of the methods, programs, and devices disclosed herein are shown. [Figure 17] Implementations of the methods, programs, and devices disclosed herein are shown. [Figure 18] Implementations of the methods, programs, and devices disclosed herein are shown. [Figure 19] Implementations of the methods, programs, and devices disclosed herein are shown. [Figure 20] Implementations of the methods, programs, and devices disclosed herein are shown. [Figure 21] Implementations of the methods, programs, and devices disclosed herein are shown. [Figure 22] Implementations of the methods, programs, and devices disclosed herein are shown. [Figure 23] Implementations of the methods, programs, and devices disclosed herein are shown. [Figure 24] Implementations of the methods, programs, and devices disclosed herein are shown. [Figure 25] Implementations of the methods, programs, and devices disclosed herein are shown. [Modes for carrying out the invention]
[0030] Referring to the flowchart in Figure 1, a computer implementation method for designing a 3D modeled object representing a manufactured product (i.e., a product) is proposed. The design method in Figure 1 involves a user interacting with a 2D block representation of the 3D modeled object displayed by a computer system (e.g., one or more screens of the computer system or another computer system provided by the computer system), in an ergonomically improved manner. The interaction takes place within a software application running locally on the computer system, or within a web application provided to a local workstation by the computer system (e.g., remotely). In this disclosure, particularly in Figure 1, where actions are shown as being performed by "that" computer system, it is understood that these actions may, in practice, be at least partially performed and / or triggered by such software or web application.
[0031] The design method includes simultaneously displaying the 3D shape representation and the 2D block representation of the 3D modeled object using a computer system (S10). This allows the user to interact with the 2D block representation while simultaneously viewing the 3D shape representation. The 2D block representation generally provides an ergonomic interface for defining and editing parameters related to the shape of the product to be manufactured, while the 3D shape representation allows the user to directly see the final result and thus visualize the exact shape that will ultimately be manufactured. In S10, the design method may display the 3D shape representation and the 2D block representation side by side, for example, in two separate windows or two separate scenes in the same window, either side by side on the same screen or on one of two separate screens. Alternatively, in S10, the design method may overlay one of the 3D shape representation and the 2D block representation on top of the other, for example, the 2D block representation may be overlaid on top of the 3D shape representation (for example, in the foreground of the 3D shape representation) (see, for example, Figure 3). Although represented by a single box in the flowchart of Figure 1, the simultaneous display of S10 may be performed throughout the rest of the design method such that each user interaction of the design method resulting in an update of the 2D block representation and / or the 3D shape representation may result in an update of what the user sees on the screen. The display (S10) update may be performed automatically and / or in real time when the computer system determines whether to update the 2D block representation and / or the 3D shape representation (the term "real time" here and / or in other uses of this term in the rest of this disclosure may mean a delay of up to 10 seconds, or even 1 second).
[0032] The 2D block representation displayed in S10 includes a block node, one or more input and output connectors on the corresponding block node, and an arc between the output connector of the first block node and the corresponding input connector of the second block node.
[0033] A “block node” means any 2D shape that is block-shaped, such as a rectangle or square, or alternatively, any other polygon such as a trapezoid, circle or ellipse, or any other type of block-like shape that is distinguishable as a block to the user. The 2D block representation may be displayed on a background, and different block nodes may be physically separated on the display, for example, having a non-zero gap between each pair of block nodes. A “block node” is a node in a virtual graph, which consists of blocks as its graph nodes / vertices, and has a graph arc / edge between two graph nodes if there is at least one arc between two corresponding block nodes (in the 2D block representation). This virtual graph can be called a “graph corresponding to a 2D block representation”.
[0034] Each corresponding block node's one or more input and output connectors may be represented by corresponding graphics displayed on the corresponding block node, for example, by corresponding symbols displayed on the corresponding block node. The corresponding block node may include a border, and at least one such corresponding graphic (e.g., symbol) may be displayed on the border. Such corresponding shapes (e.g., symbols) may be smaller than the corresponding block node, for example, at least one-tenth of the area occupied in a 2D block representation (i.e., the area occupied on the screen). Each such corresponding shape (e.g., symbol) may be a small, compact symbol, for example, a dot, a bullet, or a square, or any other type of shape that is distinguishable to the user from the block node. Different connectors may be physically separated on the display, for example, there may be a non-zero gap between each pair of connectors. Each corresponding block node's one or more input connectors may all have corresponding shapes that are visually identical or identical in shape, and these corresponding shapes may optionally be visually identical or identical in shape to the corresponding shapes of the output connectors of the corresponding block node. Optionally, one or more input connectors of all block nodes may have corresponding shapes that are visually identical or identical in shape, and these corresponding shapes may, further optionally, be visually identical or identical in shape to the corresponding shapes of the output connectors of all block nodes. All connectors may be represented, for example, by the same dot symbol. Optionally, all block nodes may be oriented in the same way within the 2D block representation, and all input connectors within the 2D block representation may be located on the same side of their corresponding block nodes, for example, to the left of their corresponding block nodes, and / or all output connectors within the block representation may be located on the same side of their corresponding block nodes, for example, to the right of their corresponding block nodes.For example, each block node may be represented by a corresponding rectangle (or rectangular shape), and each rectangle may be oriented so that its sides are parallel to the edges of the screen. All input connectors of each block node may be represented on the left side of the rectangle by the same or identical dot shape / symbol, and all output connectors may be represented on the right side of their corresponding block node rectangle by the same or identical dot shape / symbol (e.g., the same dot shape / symbol as the input connectors) (see, for example, Figure 3).
[0035] Each arc may be represented by a corresponding line connecting the shape / symbol (e.g., a dot shape) of the output connector of the first block node to the shape / symbol (e.g., a dot shape) of the corresponding input connector of the second block node.
[0036] Block nodes, connectors, and arcs may each be user-selectable, for example, by the user graphically interacting with a 2D block representation, and in particular by the user graphically interacting with the element to be selected, for example, by using a mouse or a haptic device such as a mouse or touchpad or touchscreen. The system may be configured to allow the user to perform such selections by optional select-move-release functionality (for example, by clicking or touching the mouse at a first position, moving the cursor or screen touch to a second position while maintaining the click or touch, and releasing the click or touch at the second position), for example by clicking or touching the mouse or screen on a block node, connector, or arc, and / or by the user drawing a selection area that includes at least a portion of a block node or arc, or the entirety of a connector (e.g., a graphical selection box or rectangle). After each user selection of a block node, connector, or arc, visual feedback such as visual highlighting of the selected element (e.g., a change in color or intensity or opacity) or slight movement of the selected element (e.g., bounce feedback) may automatically follow in real time. Such graphical interaction allows users to easily edit 3D modeled objects by manipulating 2D block representations, and any selections referred to in this disclosure can be performed accordingly.
[0037] Therefore, such 2D block representations can be easily designed and / or edited by a user who interacts graphically with the system, instantiating block nodes, moving instantiated block nodes via drag-and-drop behavior, and / or instantiating arcs between connectors by, for example, selecting two connectors in sequence, and / or dragging and dropping one or more ends of an instantiated arc to connect each end to a connector. The selection of block nodes and / or connectors may also trigger the display of a dialog box, for example, containing editable data fields, for the user to enter or modify values, for example, using the keyboard or a displayed scroll bar.
[0038] Each block node represents a corresponding operator in a given set of operators. "Predetermined" means functional data (here, a set of operators) that are run on or supported by software / applications supplied to a computer system, i.e., a portion of computer program instructions that make up an application. "Operator" means a set of computer data configured to take input data, process said input data, and provide output data resulting from the processing. Thus, each operator in a given set of operators has one or more inputs and at least one output. Therefore, in the block node referred to as shown in S10, each input connector represents the corresponding input of the corresponding operator represented by the corresponding block node, and the output connector represents the output of the corresponding operator represented by the corresponding block node. In addition to any inputs represented by corresponding input connectors, any corresponding operator may optionally include one or more internal parameters that can be edited by the user, for example, by the user selecting an operator, by the computer system displaying one or more editable value fields, or by transitioning an already displayed value field from editable to non-editable, by visual feedback displayed to the user to notify the user of such transition, and by entering or modifying at least one value of an internal parameter in at least one editable value field.
[0039] Here, the 2D block representation may optionally include additional block nodes that are non-standard in that they do not have input connectors, either because the input data of the operators represented by such block nodes is hidden from the user and therefore uneditable, or because the block nodes output static data rather than dynamic results of operations. The latter option could be, for example, a “reference” block node that may provide a common reference frame 0xyz to the design, and / or primitive block nodes (integers, floating-point numbers, length, etc.) (see, for example, the block node “Length.1” in Figure 7). Alternatively, such references and primitives may be represented within the block nodes that they supply.
[0040] For example, an operator that accepts an integer value as input may be represented by a first block node representing the operator, a second block node that outputs an integer, and an arc from the output connector of the second block node to the corresponding input connector of the first block node. The second block node may be an instance of a general integer block node, and the user may define the integer value by parameterizing the block node. This makes the second block node reusable. Alternatively, instead of such a second block node, the integer value may be defined directly in the first block node as an internal parameter (see, for example, data field 400 in Figure 4, which allows direct input of a length value). A shape similar to, or identical to, or of the same shape as, the input connector may be displayed on the first block node, and as described above, may be selectable by the user to perform such parameterization by selecting the shape and entering or modifying a value in the corresponding editable data field.
[0041] Additionally or alternatively, the 2D block representation may optionally comprise one or more block nodes, each having one or more input connectors, which may optionally be connected to output connectors (for input data flow) via arcs, or may remain unconnected and be selectable by the user for direct input of data values at the input connectors. This provides flexibility to the user.
[0042] Additionally or alternatively, a 2D block representation may optionally include additional block nodes that are non-standard in that they do not have output connectors. This could be, for example, a "watch" block node that allows viewing of a 3D shape of a "partial result" at a particular output connector of the 2D block representation. The output of such a block node would be that partial 3D shape, which only needs to be displayed to the user, for example, when the block node is selected, and is not intended to be input to any other block node.
[0043] Furthermore, one or more (standard and / or non-standard) block nodes of a 2D block representation may each have several output connectors, rather than just one. Each such output connector may be individually selectable by the user, for example, by graphically interacting with the output connector. Thus, when the expression “output” or “output connector” is applied in this disclosure with respect to a given operator or block node, it should be understood to refer to one of the outputs or one of the output connectors when the given operator or block node has several outputs or output connectors. Each output, and therefore output connector, of such a given operator or corresponding block node may follow a predetermined ordering, and at least one output or output connector is defined as a unique main output or output connector. Where there is ambiguity, when the expression “output” or “output connector” is applied with respect to a given operator or block node, it refers to such a main output or main output connector. According to some examples, a design method may include, for example in S20, selecting one output connector without focusing on the individual output connectors to be selected by graphically interacting with its corresponding block node. In such cases, the computer system can directly interpret the selection of the corresponding block node as the selection of its main output connector.
[0044] In software / applications, each operator in a given set of operators has a corresponding data identifier, i.e., it is referenced by a unique data index, name, or label, which can point to, thereby enabling the instantiation of the operator in a 2D block representation instance, such as the 2D block representation shown in S10. Each input of each operator further has a corresponding data identifier, and similarly, each output of each operator has a corresponding data identifier. Such identifiers enable the organization of data flows in the instantiation of the 2D block representation shown in S10, where data can be marked / identified to be input to a marked / identified operator so as to yield marked / identified output data, which can then be flowed to any other process, such as other operators. The operator identifiers, input identifiers, and output identifiers can form one or more indexes. For example, software / applications may maintain three indexes, including a first index for storing operator identifiers, a second index for storing input identifiers, and a third index for storing output identifiers. In other words, each identifier is a corresponding index value (e.g., an integer) from a corresponding index (e.g., an arbitrarily selected set of consecutive and / or integers from 1 to N). Indexing the input (and output) connectors across all input (and output) connectors across all operators in a given set, rather than within each corresponding operator, allows for stronger distinction between input (and output) connectors and enhances prediction (S40).
[0045] Each arc lies between corresponding pairs of connectors, specifically, from the (starting) output connector of the first (starting) block node to the (ending) input connector of the second (ending) block node. Each arc represents a data flow from the output connector of the first block node to the corresponding input connector of the second block node. Since each block node represents a corresponding operator (sometimes static, i.e., taking only internal parameters as input), each output connector of each block node represents a data value output by the operator. The arcs arising from the above connectors represent the flow of the above data values toward the input connector to which the arc reaches. This is interpreted by the application as the data value output from the above output connector being input to the second block node at the above input connector.
[0046] The same output connector may be the origin of several arcs, meaning that data output from the above output connector flows to several destinations (several input connectors of other block nodes). Each input connector may (for example, in most cases) be at most the end of one arc, to avoid ambiguity. Alternatively, some input connectors may accept multiple input arcs, only under certain conditions, which is interpreted as the acceptance of a collection of objects. Optionally, as will be further detailed later, each input connector may accept a collection of objects through a single arc (see, for example, the arc marked "Size:3" in Figure 3, showing a collection of three objects coming in through a single arc). Further optional, at least some input connectors may be dynamically duplicated to increase the potential data flow of objects of the same nature. Such duplication may involve the addition of certain shapes (see, for example, the input connector "pts" of block node "Spline.1" in Figure 3, which has a dotted line surrounding the connector to illustrate such duplication).
[0047] Therefore, the 2D block representation is configured such that the execution of the data flow represented by the arcs of the 2D block representation corresponds to the processing of data, starting from one or more root block nodes (i.e., block nodes that have no input connectors or no arcs connected to any input connectors of the node) and following the data flow represented by the arcs in the arc direction, processing the data sequentially and / or in parallel (depending on the structure of the 2D block representation) according to the operators represented by each block node encountered. The 2D block representation actually represents a global operation corresponding to a compound function of operators defined by the arrangement of arcs connecting pairs of connectors of block nodes. The execution of the data flow corresponds to the evaluation of the compound function.
[0048] The execution of the data flow may be performed by the application's data flow engine. The execution of the data flow may, in particular, include compiling the data flow represented by a 2D block representation into a set of operations including operators, inputs, internal parameters, and outputs defined by the 2D block representation. Compilation can simplify the calculations according to predetermined rules so that the set of operations yields the same results as the exact data flow, but does not follow it step-by-step. This is standard in algorithmic compilation techniques. The 2D block representation displayed in S10 and the updated 2D block representation executed in S110 are consistent (i.e., compilable) so that the data flow engine can actually successfully compile them. This can be ensured by the logical consistency of the 2D block representations and / or by the data flow engine being configured to resolve any logical inconsistencies, for example, based on predetermined (e.g., arbitrary) rules.
[0049] In the example, the data processing / flow represented by the 2D block representation is finite, for example, because the 2D block representation does not contain cycles, i.e., it does not contain arc paths that start from one output connector and end at the same output connector. Furthermore, the graph corresponding to the 2D block representation may be aperiodic. If the user attempts to create such cycles during the design of a 3D modeled object by designing a 2D block representation, the computer system may output a warning indicating a compilation error or may prohibit the creation of the cycles. Alternatively, such cycles may be allowed, but have certain rules in terms of interpreting the implied data flow such that they are finite. For example, a given set of operators may include a loop operator that allows the generation of values according to some loop / iterative algorithm. Such an operator may allow feedback, which can result in arc cycles. The loop operator may have a value as an input or internal parameter that controls the number of iterations / generations, which makes it finite and stable.
[0050] Alternatively or additionally, each input connector may be connected to an arc so that data actually flows to the input connector, and / or each input connector may have a default value to be used if the arc does not reach the input connector. The default value may be a null value by choice, for example, if the input represented by the input connector is optional when evaluating the block node's operator. Similarly, any operator with internal editable parameters may have a default value for the parameter used to evaluate the operator if the user does not enter a specific value. If one or more null values are entered, the block node may evaluate the operator using one or more null values, or ignoring them (for example, a line operator may have a supporting plane for the line as an optional input, which can be optional since the line can be drawn using only two points as input), or alternatively, replacing them with the default values of the associated default connector and / or internal parameters, or further alternatively, for example, if the input is considered mandatory, it may indicate an error and / or non-evaluation of the operator (e.g., outputting an empty value). For example, a given set of operators may include a coordinate-based point operator, which outputs a geometric point based on input lengths x, y, and z, where the point has coordinates (x, y, z) with respect to a reference frame. The default values for all length input connectors x, y, and z of a block node representing a coordinate-based point operator may be 0 mm. If one of the input connectors x, y, and z is not linked to any input arc supplying a data value to the input connector, or if a null value is supplied to the input connector, the coordinate-based point operator may use the default value of 0 mm.
[0051] If a logical inconsistency is introduced into the 2D block representation, or if one is introduced, the dataflow engine may automatically resolve it, issue a warning, and / or prevent the introduction of the inconsistency in any predetermined manner.
[0052] For at least one specific block node (hereinafter referred to as a “geometric” block node), for example, all block nodes in a 2D block representation, the (main) output of the corresponding operator represented by each such block node is a corresponding set of one or more geometric objects, i.e., a set of objects, each representing a geometric shape. A “geometric” block node may be such in nature because it is designed to systematically output geometric shapes, or because of the nature of its input in a 2D block representation, for example, because such input is geometric and the operator represented by the “geometric” block node does not alter this geometric property. A given set of operators may include, in particular, a list-making operator that creates a list of input objects. If the input objects of an operator are geometric, the corresponding block node is considered geometric in a 2D block representation.
[0053] Using such geometric block nodes, the 2D block representation is configured so that the execution of the data flow represented by the arcs of the 2D block representation outputs what is shown in the 3D shape representation, particularly in S10 or S120.
[0054] This disclosure provides a description focusing on geometric block nodes (i.e., block nodes within at least one specific block node as mentioned above), but it may be equally applicable to other types of block nodes. In particular, while the selection (S20) is presented as taking place within at least one geometric block node, the user may instead perform the selection in S20 non-exclusively within at least one geometric block node, or exclusively outside at least one geometric block node, and the rest of the design method in Figure 1, particularly the predictive output in S40, may still be performed. This is because, for example, non-geometric operators are included in the dataset used in pre-training of the machine learning and / or the dataset obtained in S25. However, since this discussion focuses on explaining how the design method may assist designers in modeling 3D shapes that will ultimately be generated in the real world through manufacturing, the emphasis is placed on the case of geometric block nodes.
[0055] In object-oriented programming, an application manages a given set of object types and object instances of each of one of the types within that set. Each object type may be identified by a unique label, marker, or index within the application. At least some of the object types are geometric object types. A 2D block representation instantiates objects within a given set of object types. For example, each value entered by the user as an internal parameter value of a given block node is an instance of one of the object types. Each output value provided by the output connector of any block node and then entered into the input connector is an object instance or a collection of object instances, each object instance being one of the object types.
[0056] For at least each geometric block node, that is, for at least one block node, the output of the corresponding operator represented by the block node is a corresponding set of one or more geometric objects, the output of the corresponding operator (in the corresponding output connector) has dynamic object cardinality. Optionally, the outputs of operators of one or more non-geometric block nodes may also have such dynamic object cardinality. In other words, the output provided by such a block node in the corresponding output connector may include several object instances that are variable depending on the values of one or more internal parameters of the operator provided in the block node, and / or the values and / or cardinality of one or more inputs of the operator provided in the block node. Thus, a block node may output, depending on the context, a unique object or a collection of several objects in the corresponding output connector.
[0057] For example, a given set of operators may include a sequence operator designed to output a list of one or more integers depending on the input value of the sequence operator, the input of which may include a lower bound "inf", an upper bound "sup", and a number of integers "nb" to be added to the list. A given set of operators may additionally or alternatively include a mesh vertex operator, which consists of outputting all vertices (i.e., geometric points) of an input mesh as a list. A given set of operators may additionally or alternatively include a list creation (or list construction) operator, which consists of creating a list from one or more inputs provided to a corresponding block node. Such operators are designed and intended to output a collection of a variable number of objects (i.e., a dynamic number, depending on the current instance of the 2D block representation, in particular its data flow at the location of the relevant block node), even though in exceptional circumstances (e.g., if the "nb" input connector is supplied by an integer value equal to 1 at the block node of the sequence operator, which is "insufficient capacity", but the use of the operator may still be permitted).
[0058] A given set of operators may additionally or alternatively include, and other examples of operators intended to output a collection of objects of dynamic cardinality include the following known operators: the rectangular grid operator (places points on a plane in a rectangular pattern), the grid UV operator (places points on a surface), the color gradient operator, the string splitting operator, the normal random number operator, the sampling operator (provides sampling of points in space), the mesh edge operator and / or mesh face operator (outputs mesh edges and / or faces), the item acquisition operator, the deepening operator, and / or the flattening operator.
[0059] The associated output connectors for the above operators may be marked in a computer system (application) with a “collection” label indicating such intended output of a collection of objects rather than a unique object. In contrast, output connectors primarily designed to output a single object may be marked with a “unique” label indicating such intended output of a unique object. This marking may be performed in any way, for example, by a database that associates output identifiers with corresponding labels.
[0060] In addition, for (at least) each geometric block node, and optionally for at least one (e.g., each) non-geometric block node, at least one (e.g., each) input of the operator may have dynamic object cardinality. In other words, the corresponding input connector is configured to receive several object instances that may vary depending on the origin of the incoming arc. The operator may be configured to anticipate such a collection and thereby process the collection of input objects as a whole. Thus, each of such input connectors may be associated accordingly with a “collection” label or a “unique” label.
[0061] For example, a given set of operators may include spline operators and / or polyline operators, each configured to take a list of points as input and output a spline curve controlled by a list of points or a polyline linking the list of points. In such an example, the operators expect a list of points as input and thereby process the collection one at a time to provide a single output geometric object.
[0062] However, applications may also be configured to manage the data flow of collections in connectors targeting unique objects. This can be applied to all connectors for geometric (and optionally non-geometric) block nodes. Connectors remain labeled "unique," but depending on the data flow, they may pass through collections of objects rather than unique objects. This behavior can also be applied to connectors that expect collections, in which case each connector is aware of collections of multiple collections flowing through it.
[0063] In particular, the operator may be designed to process a single / unique object as input, and the computer system (e.g., a dataflow engine) may be configured to interpret the dataflow of an input collection of objects (instead of just one unique object) as multiple calls to the operator in order to ensure compilation. In other words, the operator can treat each object in the input collection as one single / unique input, compute the corresponding output, and thereby output the corresponding collection of output objects. The computer system (e.g., a dataflow engine) may be configured (e.g., at compile time) to accept only the presence of a collection of N objects in one input connector and the corresponding unique objects in one or more other input connectors, and then evaluate the operator N times, using the corresponding object from the collection for that input connector each time, and the corresponding unique object for each other input connector each time, thereby outputting a collection of N output objects. Alternatively, the computer system (e.g., a dataflow engine) may be configured (e.g., at compile time) to accept the presence of a collection of N objects in one input connector and potentially accept the presence of collections of objects in one or more other input connectors, in which case the collections would necessarily also have a cardinality of N. The execution of the data flow can still evaluate the operator N times in such cases, each time using an index i from 1 to N to retrieve an input object from each collection, and each time using the corresponding unique object for the remaining input connectors (that do not have an input collection), thereby outputting a collection of N output objects. If the cardinality of the inputs differs, the system may output a warning and compilation may fail.
[0064] For example, a given set of operators may include a point operator based on coordinates as described above, and input connector x may be supplied with a list of N length values x1, ... xN instead of a single value, and a single value y1 and a single value z1 for other input connectors. In such a case, the operator outputs a collection of N points: (x1, y1, z1), ... (xN, y1, z1). The same operator may also be given a list of N length values x1, ... xN for the x input connector, a list of N length values y1, ... yN for the y input connector, and a single value z1 for the z input connector. In such a case, the output of the block node may be (thanks to the dataflow engine which optionally supports this situation) a collection of N points: (x1, y1, z1), ... (xN, yN, z1), where xi is always equal to yi. If the two lists x1, ... xN and y1, ... yN do not have the same cardinality, the system outputs a warning and compilation fails.
[0065] Such a collection of points can then be input to an operator that expects a collection of points, such as the spline or polyline operator described above. In the example, an operator that expects a collection of objects, such as the spline or polyline operator, may receive a collection of multiple collections of objects as input. The operator may be evaluated individually for each collection of objects. In the spline operator example, the block node receives a collection of lists of points. Each list of points yields a corresponding spline. Thus, the block node outputs a collection of splines.
[0066] Such dynamic object cardinality management provides high ergonomics to 2D block representations because it reduces the number of blocks that can be used to generate a collection of geometry. In particular, 2D block representations can be configured to use dynamic object cardinality as needed to input data into each input connector of each geometric operator block node. This provides users with high flexibility to generate complex patterns containing collections of objects.
[0067] In object-oriented programming, when combined with the concept of "type" or "data type" in computer programming, an application manages typed objects, meaning that each object flowing in an arc from an input connector to an output connector—in other words, each object passing through or received at an input or output connector—has a data / object type within a given set of object types. Each operator expects an object from one or more possible object types as input, and each operator outputs an object of one or more possible object types, depending on the operator, the operator's internal parameter values, and the object type of the operator's input. For example, the expected object type for a point operator, based on coordinates for each input connector x, y, or z, is the length object type. The expected object type for the (primary) input connector of a spline operator is the point object type, because the spline operator expects to receive a collection of points to trace a curve passing through the points mentioned above. As can be understood, the expected type comes in addition to the expected cardinality. One input connector may expect the same object type as another input connector, but the two connectors may expect different cardinalities. Therefore, all connectors can be marked with a label indicating their expected object type.
[0068] Therefore, every connector (input or output) in a 2D block representation may have a static (i.e., predefined) cardinality value and a static (i.e., predefined) object type. The static cardinality and static object type are information that exists prior to the initial creation of the 2D block representation and are stored (persistently throughout the design session, regardless of any changes to the 2D block representation) in a database that associates connector identifiers with such information (e.g., in non-volatile memory).
[0069] The static cardinality value is a value that depends on the object cardinality intended for the connector. It may optionally be a binary value indicating whether the cardinality is 1 or greater than 1, i.e., information indicating whether the connector targets a unique / single object or rather a collection of (several) objects for the connector to pass through. Such a binary value improves the accuracy of predictions (S40) because the results of the machine learning function may depend primarily on whether the cardinality is 1 or greater than 1, rather than the exact number of objects when the cardinality is greater than 1.
[0070] A static object type is information that indicates the object type within a given set of object types that a connector targets. This given set of object types may include generic object types to manage cases where the same operator targets different possible specific object types.
[0071] Therefore, the static cardinality value and static object type do not depend on the specific use of connectors in the 2D block representation under design.
[0072] Therefore, in addition to such static values, every connector (input or output) of a 2D block representation may also have a used (e.g., dynamic) cardinality value and a used (e.g., dynamic) object type, which are referred to as "internal" cardinality / types or "evaluated" cardinality / types, as opposed to "predefined" (also called "defined") cardinality / types. Used or dynamic object cardinality and used or dynamic object type are information that depends on the current structure of the 2D block representation under design, and these may be computed from the 2D block representation as needed, for example, or alternatively, they may be computed and stored in a volatile manner, for example, on volatile memory such as RAM (therefore, they are readily readable as needed throughout the design session but are updated in response to modifications to the 2D block representation that affect the values).
[0073] The value of the usage or dynamic cardinality is a value that depends on the actual object cardinality of the connector in the current 2D block representation in which it is instantiated. The value of the usage or dynamic cardinality may correspond to the value of the static cardinality (i.e., defined in the same domain as the value of the static cardinality). Therefore, it may optionally be a binary value indicating that the usage or dynamic cardinality is 1 or greater than 1.
[0074] As explained earlier, connectors that have a static cardinality value indicating that they expect a collection (e.g., the "point" input connector of a spline operator block node, or the integer list output connector of a sequence operator block node) can have different usage cardinality values. For example, an integer list output connector may output a single integer if the input / parameter of a sequence operator block node indicating the number of integers to be output is set to 1. In such a case, the sequence operator block node may be used "undercapacity," which may be permitted by the dataflow engine. Conversely, the dataflow engine may prohibit (prevent and / or output a warning) a spline operator from inputting a unique point to its point list input connector. Therefore, when the cardinality value is a binary value, the usage cardinality value is not dynamic, as it is always equal to the static cardinality value, i.e., the value indicating that the usage cardinality is greater than 1.
[0075] The used or dynamic object type is information indicating an object type within a given set of object types flowing through a connector. For at least one output connector of a geometric block node, and optionally for at least one output connector of a non-geometric block node, the output of an operator has a dynamic object type, meaning that it is variable depending on the current instance of the 2D block representation. In particular, at least one input of a corresponding operator may have a dynamic object type so as to supply different types of objects to the corresponding input connector of the corresponding block node. The object type in an output connector (i.e., the type of object output in the connector) depends on the input object type and may vary as a function of the input object type.
[0076] For example, a given set of operators may include one or more transformation operators, one or more extraction operators, and / or one or more list assembly operators. Such operators are operators that do not affect the type of their inputs, and rather are directed to manipulate them in a way that preserves the type. Such operators may be allowed to take different object types as inputs, since their operation is independent of the input object type. A given set of operators may include, for example, any one or any combination of the following operators: translation operators that translate geometric objects, rotation operators that rotate geometric objects, scaling operators that scale geometric objects, assembly operators that assemble geometric objects together, such as sub-element operators that extract sub-parts of an object, boundary operators that extract the boundaries of a geometric object (e.g., boundary curves if the object is a surface, or boundary surfaces if the object is a volume), and / or construction list (or creation list) operators that build a list from multiple input objects. Each such operator block node may have a dynamic input connector and, correspondingly, a dynamic output connector. The object type of the output connector may vary depending on the object type of the input connector that accepts different object types.
[0077] In contrast, a given set of operators may include one or more geometric operators that do not output dynamic object types. In the case of such operators, the output connector usage / internal object type is always the same as the static / defined object type of the output connector. This is especially true for geometric operators that generate geometry from scratch. A given set of operators may include, for example, any one or any combination of the following geometry generation operators: one or more point generation operators that necessarily output points (such as a point operator by coordinates), a circle generation operator, one or more curve generation operators, a line generation operator, a sphere generation operator, a plane generation operator, a mesh generation operator, a spline generation operator (as presented earlier), and / or a polyline generation operator (as presented earlier). In such cases, the output is necessarily a given set of object types, e.g., a constant set of geometric point object types, geometric line object types, or geometric plane object types.
[0078] A 2D block representation can include at least one input connector that corresponds to an input having a dynamic object type, so that a given set of object types includes one or more first object types that are each compatible with one or more second object types. The compatibility of a first object type with a second object type means that an input connector having a second object type as its static object type can also accept input data of the first object type. The compatibility relationships are not necessarily symmetric.
[0079] For example, a transformation operator may expect a general geometric object (or geometry) type object as the input to be transformed, but the operator can take more specific types of objects as input, such as geometric curve type objects. The transformation operator can indeed transform curves without any problems. As another example, a point operator by coordinates may have a length type as the static object type for its x, y, and z input connectors, each of which may accept a real type (i.e., a real number) or an integer type (i.e., an integer) object, and such an input object may be interpreted as having a length equal to the input value assigned in a given unit of length, such as meters or millimeters.
[0080] A given set of object types may form a tree of object types, the tree having, for example, connected and / or just a single root node. Thus, all object types are organized according to parent-child relationships in a single tree structure, where a child type is a specific subtype of its direct parent type. In other words, a parent type is more generic and encompasses its child types. Thus, an object of a child type presents all the attributes of an object of a parent type, and as a result, an object of a child type can be used as is (i.e., without conversion) in the behavior expected of a parent type. Each non-leaf object type in such a case is dynamic, meaning that connectors having that non-leaf object type as their static object type have dynamic object types. In particular, each descendant object type (child or grandchild descendant of a child, for example) of the above non-leaf object type is compatible with the above non-leaf object type. This is because, for example, a curve object type may be a descendant (e.g., a child) of a geometry object type, as is the case with conversion operators as described above. Such compatibility allows the use of operators that accept generic object types depending on the situation, such as geometric operators that do not affect the type, such as those presented above.
[0081] In a tree, the parent node of a given node is the node from which an arc begins and reaches the given node (all arcs are directed). The descendant nodes of a given node are the nodes from which one or more arcs in a sequence begin and reach the given node.
[0082] A given set of object types (e.g., a tree) may contain any one or any combination (e.g., all) of the following lists of types: - A given set of operators may include generic or undefined (e.g., root) types, and optionally, one or more operators having generic types as their static object types, e.g., list-making operators. - Literal types (for example, those that have a root type as a parent or ancestor), geometry or geometric object types, and matrix types, - Real number types, string types, and Boolean types (for example, those that have a literal type as a parent or ancestor), - Point types, curve types, surface types, and volume types (for example, those that have a geometry type as a parent or ancestor), -(For example, a vector type that has a matrix type as a parent or ancestor) -Integer types and magnitude types (for example, having a real number type as a parent or ancestor), the magnitude type has length types and angle types as children, - Line types (for example, those that have a curve type as a parent or ancestor), and - A plane type (for example, one that has a surface type as a parent or ancestor).
[0083] Therefore, at least part of the tree can consist of the following structure of object types, where indentation represents parent-child relationships. • Undefined / Root / Generic ·literal Real numbers ·integer ·magnitude ·length ·angle ·string ·Boolean • Geometry / Geometric Objects ·point ·curve ·line • Surface ·plane ·volume · Matrix • Vector
[0084] The 2D block representation displayed in S10 may include, for each corresponding type of any one or any combination (e.g., all) from the list of types, at least one connector whose static / defined type is the corresponding type.
[0085] As an addition or alternative, when a given set of types is a tree, the 2D block representation may have at least one connector for each corresponding leaf type of any one or any combination (e.g., all) of the list of types, where the type used / internal type is the corresponding type.
[0086] In addition, or alternatively, a given set of object types (e.g., a tree) may comprise one or more first object types, each convertible to one or more corresponding second object types. Such corresponding first object types convertible to corresponding second object types may not be children or descendants of the corresponding second object types, unlike the corresponding second object types themselves. However, the first object types may be superior (i.e., parents or ancestors) to the second object types. "Convertible" means that the computer system / application / dataflow engine includes a corresponding conversion algorithm configured to change / convert each such first object type to such corresponding second object type. Thus, the algorithm / conversion may be executed whenever an object of the first object type is input to an input connector that expects (has as a static object type) an object of the second object type. As a result, each first object type convertible to a corresponding second object type is thereby compatible with the corresponding second object type. This is the case, for example, with integer object types or real object types, both of which can be converted to length object types. As described above, in such cases, the given algorithm consists of taking the input integer or real number as is and assigning a predetermined length unit to that value. Such compatibility gives users flexibility, not being bound by precise type matching or descendants when creating arcs between connectors. This can prove to be extremely ergonomic, as a given set of object types can include 10, 50, or even more than 100 different object types, making it difficult for the user to always select only one object type that is permitted in any situation.
[0087] By convention, the dynamic object type of a collection of objects of different object types is the nearest top-level object type in the tree that is common to all object types in the collection.
[0088] The system (e.g., the dataflow engine) may support any one or any combination (e.g., all) of the following transformability rules: - Real number types can be converted to integer types (for example, by using floor or ceiling functions), length types (for example, by adding units that can systematically be in meters), and / or angle types (for example, by adding radian units). - Integer types are convertible to length types (for example, by adding units that can systematically be meters or millimeters) and / or angle types (for example, by adding units in radians). - Boolean types are convertible to integer types (for example, True is converted to 1 and False is converted to 0), - Point types can be converted to vector types (for example, the coordinates of a point can be like the coordinates of a vector), - The curve type can be optionally converted to a plane type only if the curve is a plane (for example, by taking any plane that contains a plane or curve); otherwise, an error is output. - Line types can be converted to vector types (for example, by obtaining a unit vector oriented along the line), - Plane types can be converted to vector types (for example, by taking a unit vector perpendicular to the plane), line types (for example, by obtaining an infinite line perpendicular to the plane), and matrix types (for example, by considering a 4x4 transformation matrix, the geometry containing the plane is oriented using a first column of the matrix representing the plane's X direction, a second column representing the plane's Y direction, a third column representing the plane's Z direction, and a fourth column representing the position of the plane's origin O, and such transformations can be useful in representing changes in the frame in an easy way), and / or - Volume types can be converted to surface types (for example, by obtaining the boundary surface of the volume).
[0089] The 2D block representation displayed in S10 may include at least one occurrence of each convertibility in the list (i.e., the object is converted at least once in the input connector according to each rule).
[0090] The system / application / engine may be configured such that a first object type is compatible with a second object type only if the first object type is a descendant of the second object type or if the first object type is convertible to the second object type. Otherwise, if the first object type is not identical to the second object type, the system may output an error indicating the incompatibility. This imposes constraints on the design and avoids ambiguity.
[0091] Referring further to Figure 1, the design method includes, after and / or during the display (S10), the user performing the selection of one output connector by graphically interacting with the 2D block representation (S20), as described above. Here, we describe the case of a geometric design in which the user is shaping the final product to be manufactured, but the same type of user interaction may also be supported for non-geometric designs.
[0092] The output connector selected in S20 does not have to be connected to any arc, or it may already be connected to one or more arcs. For example, a user may want to attach a new block node to an output connector that is already linked to other block nodes via an arc, as shown in Figures 17 and 18.
[0093] The selection performed in S20 may include the user graphically interacting with an output connector, for example, by clicking or touching an output connector. Alternatively, the selection performed in S20 may include the user graphically interacting with a block node that may be located in a position other than the output connector displayed on the block node. The system can then interpret such an action as a selection of an output connector, for example, a (primary) output connector. For example, a block node may optionally have one and only one output connector, and the system can then interpret such an action as a selection of an output connector. The system can optionally support both options (i.e., graphically interacting with an output connector and / or a block node). In the example, the design method is repeated, including performing the first option at least once and the second option at least once.
[0094] The block node of the output connector selected in S20 has at least one (e.g., exactly one) preceding block node. The “preceding block node” of a corresponding block node means another block node having at least one output connector connected (e.g., by arc) to at least one input connector of the corresponding block node. For example, the corresponding block node may have only one input connector, and the preceding block node may have only one output connector, which is arc-connected to the input connector of the corresponding block node.
[0095] (In S20) The block node of the selected output connector may be evaluable. For example, data can actually flow through the block node (e.g., all the necessary input connectors of the block node can be connected to other block nodes). Therefore, the selected output may have a usage / internal (e.g., dynamic) object type.
[0096] The design method may then involve different actions using trained (i.e., already trained) machine learning functions, such as a trained deep learning neural network, and datasets based on multiple previously executed designs. These actions may be automatically triggered (i.e., immediately and as a direct result) when the user makes a selection in S20, or alternatively, when the user later invokes a specific function of the system.
[0097] The design method includes, in particular, obtaining a trained machine learning function. Obtaining a trained machine learning function may include retrieving the trained machine learning function (e.g., from local or remote memory) or receiving it (e.g., from a remote system). Obtaining may also include obtaining a machine learning function (e.g., having randomly instantiated weights and parameters and not trained) and training the machine learning function to obtain a trained machine learning function. Obtaining may further include obtaining a training dataset and training the machine learning function on the training dataset. Training a machine learning function and obtaining and / or generating a training dataset are described further below in this disclosure.
[0098] A pre-trained machine learning function may be trained to take as input the data identifier of an operator (e.g., an index), the data identifier of the output connector of the block node representing the operator (e.g., an index), and the object type of the output connector (e.g., an index in the indexing of a given set of object types). The pre-trained machine learning function may be further trained to provide as output one or more operators from a given set of operators (e.g., ranked using scores or probabilities).
[0099] The design method further includes obtaining a dataset containing multiple data (S25). Obtaining (S25) may include retrieving the dataset (e.g., from local or remote memory) or receiving it (e.g., from a remote system). The dataset is based on multiple previously executed designs. The multiple previously executed designs may include a number of “default” previously executed designs not created by the user (e.g., stored in local or remote memory). The multiple previously executed designs may, in particular, include 3D modeled objects each containing corresponding 2D block representations designed by multiple other users and / or the same or other organizations and archived in a searchable manner. Thus, the design method is built upon previously created knowledge. The multiple previously executed designs may include, for example, mostly (more than 50%), substantially all (e.g., more than 90%), or all (100%) completed designs. Previously performed designs may include, for example, designs that perfectly represent the shape of a product to be manufactured, which can actually be manufactured in that way (i.e., without further design) for the majority (more than 50%), substantially all (e.g., more than 90%), or all (100%). Additionally or alternatively, previously performed designs may include (e.g., consist of) a number of designs previously created and / or selected by the user.
[0100] The dataset can be obtained by searching for 2D block representations of previously executed designs. Such 2D block representations can be retrieved from an internal database and / or a catalog of completed and validated previous designs. In the example, each block node in at least one (e.g., each) 2D block representation of a corresponding design among several previously executed designs may be a block node through which data actually flows, i.e., is evaluated or evaluable, having, for example, all input connectors connected to the corresponding block.
[0101] The dataset may differ from the training dataset used to train a machine learning function. For example, each entry / data in the dataset may have a different format than that of the training dataset. The dataset and the training dataset may or may not be based on the same multiple previously run designs. For example, the training dataset may be based on a set of “default” previously run designs not created by the user. Thus, the training dataset may not be user-dependent. The dataset may be based on at least one (e.g., corresponding) such design, and optionally and additionally on previously run designs created or selected by the user. Alternatively, the training dataset and the training dataset may be based on completely different previously run designs.
[0102] In particular, the dataset acquired in S25 may be dynamically / iteratively modified during the design process, taking into account all of the user's design choices in real time. In the example, the design method is repeated, and in each iteration, the dataset acquired in S25 may be different (for example, it may be updated based on previous iterations). Thus, the prediction output in S40 can be (increasingly) based on the user's previous choices. Thus, the design method can automatically adapt to the user while the user designs on the system.
[0103] The design method may include storing the dataset in non-volatile memory (e.g., either local or remote memory) after each update and / or at the end of each session. This ensures that the dataset is always updated in all previously executed designs by the user.
[0104] Each data point in the dataset obtained in S25 contains a tuple (i.e., multiple data elements linked / associated with one another). The tuple contains a first operator, represented by a first block node in the design, which is one of several designs previously created. The tuple contains a second operator, represented by a second block node in the design, which has an output connector connected to the corresponding input connector of the first block node. The tuple contains a third operator, represented by a third block node, which has a corresponding input connector connected to the corresponding output connector of the first block node. The tuple further contains an object type, which is the object type of the corresponding output connector of the first block node to which the corresponding input connector of the third block node is connected. The object type may be a usage / internal (e.g., dynamic) object type.
[0105] In the example, the third connector may have only one input connector connected to the corresponding output connector of the first block node. In other examples, the third connector may have multiple input connectors, each of which may or may not be connected to the output connector (e.g., the corresponding output connector) of the first block node.
[0106] Therefore, a tuple can have at least one "instance" in at least one of several previously executed designs. Each instantiation of a tuple in one of several previously executed designs includes a first block node, a second block node, and a third block node in the design. The first operator is represented by the first block node in the design. The second operator is represented by the second block node in the design. The second block node is the preceding node of the first block node, i.e., the second block node has at least one (e.g., exactly one) output connector connected (e.g., by one or more arcs) to at least one (e.g., exactly one) input connector of the first block node. The third operator is represented by the third block node in the design. The first block node is the preceding node of the third block node. Therefore, the third block node has a corresponding input connector connected to the corresponding output connector of the first block node. The object type is the object type of each output connector of the first block node. The object type may be an internal (e.g., dynamic) object type using the corresponding output connector.
[0107] Each data point in the dataset obtained in S25 further includes a weight. The weights depend on the degree of instantiation of the tuple contained in the data in multiple previously executed designs. At least one (e.g., corresponding) weight can be a number, e.g., a non-negative integer or a strictly positive integer. The weights and / or numbers may represent the availability and / or existence of tuple instantiations in multiple previously executed designs.
[0108] Each tuple may have no instantiations, or may have one or more instantiations, in each of the designs among a plurality of previously executed designs. Instantiations in the same design may intersect. For example, a first block of an instantiation may be a first block or a second block of another instantiation. In an example, two instantiations may be considered different instantiations when they have at least one non-identical block node (among the first, second, and third), or a non-identical object type.
[0109] The weight may correlate (e.g., depend linearly) with the number of instantiations of the tuple in each of the designs among the plurality of previously executed designs. Accordingly, the weight may increase in proportion to the number of instantiations that the tuple has.
[0110] For example, the weight may be, for example, a "count" of the number of instantiations with a coefficient. For example, the design method may include assigning an importance value (e.g., a numerical coefficient) to each design of the plurality of previously executed designs, and the (composite) weight may be the sum of several instantiations that the tuple has within the design across all designs of the plurality of previously executed designs, multiplied by the importance value of the above design. For example, the (composite) weight w is
[0111] [Formula]
[0112] may be given by, where d represents a design D among the plurality of previously executed designs, N d represents the number of instantiations that the tuple has within design d, I d represents the importance value of design d. The importance value (e.g., I d ) is always 1 (e.g., for all d, I dIt may also be =1), and the weight may be the total number of instantiations. Alternatively, the importance value may depend on whether the design has been previously performed by the user. For example, the importance value (e.g., I d ) may be 1 if the design is the default design (e.g., not executed by a user), and may be greater than 1, such as 2 or 10, if the design has been previously executed by a user. For example, I d This can be equal to 1 if d is a design that is not executed by the user, and equal to 2 (or 10) if d is a design that is executed by the user.
[0113] Therefore, the weights may represent the degree of instantiation performed by previous users and / or by current users. User choices may contribute (proportionally) more to the weights than those of previous users. This allows the design method to improve the personalization of predictions, thereby better predicting user intent and improving the ergonomics of designing the objects to be manufactured.
[0114] Retrieving a dataset (S25) may include generating a dataset from multiple previously executed designs. Generating may include receiving or retrieving multiple previously executed designs (e.g., default design and / or user-created / selected designs). Generating may include generating an entry in the dataset containing the tuple for each tuple that has at least one instantiation in at least one of the multiple previously executed designs. Generating may include, for example, the expression W = Σ d I d N d Using this method may involve calculating tuple weights as described above. Since the dataset may be stored and updated between sessions, the design may require generating the entire dataset only once per user.
[0115] The design method further includes providing the machine learning function with the necessary input data to be evaluated (S30). Thus, the machine learning function can then be evaluated using such input data.
[0116] The input data depends on the selection made in S20 and includes at least the data identifier (e.g., index) of the corresponding operator represented by the block node of the selected output connector, the data identifier (e.g., index) of the selected output connector, and the object type of the corresponding output connector (e.g., index in the indexing of a given set of object types). Such data allows the results of the machine learning function to be used in S40 to output predictions for one or more operators in a given set of operators.
[0117] The design method further includes outputting predictions for one or more operators from a given set of operators based on the results of a machine learning function and a dataset (S40). The prediction may be a system guess of one or more operators that the user would like to next instantiate at this stage of the design method. The prediction may output a single operator, e.g., the most likely operator among all operators in a given set of operators, or several operators ranked by the user's (e.g., descending) score (e.g., probability) for which they would like to instantiate. Thus, the machine learning function and dataset assist the user in the design method, in particular by suggesting one or more operators at different stages of the design, so that the user does not have to systematically explore operators to be instantiated in a completely manual, traditional, and cumbersome way. This can prove to be highly ergonomic, as a given set of operators may contain 50, 100, or even more than 200 different operators. Furthermore, the prediction may suggest one or more operators that the user has frequently selected (e.g., in multiple designs previously run) and is therefore likely to be the most relevant operators. Furthermore, since datasets may differ for each user, predictions may be customized for the current user, meaning they may reflect the user's previous choices.
[0118] In the example, the prediction may be based on a score that depends on both the machine learning function and the dataset. For example, the score of a given operator may depend on the weights of a corresponding tuple determined from a first operator, a second operator, a third operator, and an object type. The first operator may be a corresponding operator represented by a block node of the selected output connector. The second operator may be a corresponding operator represented by a preceding block node of the selected output connector. The third operator may be a predetermined operator. The object type may be an object type of the selected output connector, e.g., a use / internal (e.g., dynamic) object type.
[0119] For example, the score may increase in proportion to weight. Therefore, if the user consistently selects a given operator in instantiation, including the first operator, the second operator, and the object type, the prediction may be more likely to rank the given operator (e.g., the given operator) highly.
[0120] Outputting (S40) may include obtaining a first score (e.g., probability) for each given operator in a given set of operators as a result of a machine learning function. The first score / probability may consist of predictions for one or more operators in the given set of operators, and the predictions may use only the output of the machine learning function.
[0121] Outputting (S40) may include determining a second score for each given operator in a given set of operators. The second score may consist of predictions for one or more operators in the given set of operators, and the predictions may use only the dataset. The second score for a given operator may represent the (e.g., weighted) frequency of the corresponding tuple in the dataset.
[0122] The corresponding tuple may be determined from the first operator, the second operator, the third operator, and the object type (as described above, for example). The first operator may be the corresponding operator represented by the block node of the selected output connector. The second operator may be the corresponding operator represented by the preceding block node of the block node of the selected output connector. The third operator may be a predetermined operator. The object type may be the object type of the selected output connector. The object type of the selected output connector may be a usage / internal (e.g., dynamic) object type.
[0123] "Frequency" can be the normalized weight, i.e., the weight of the corresponding tuple normalized by all possible weights of the corresponding tuple contained in a dataset similar to the corresponding tuple. For example, the frequency of a corresponding tuple could be the frequency (e.g., relative weight) of the corresponding tuple among all (corresponding) tuples in the dataset that have the same first operator, second operator, and object type as the corresponding tuple.
[0124] Therefore, the second score may represent the frequency (e.g., weighted frequency or relative weight) or proportion of the corresponding tuple among all (corresponding) tuples in the dataset that have the same first operator, second operator, and the same (or compatible) object type as the corresponding tuple. The design method may include setting the second score to a predetermined value (e.g., 0 or 0.1) if the dataset data does not contain the corresponding tuple.
[0125] Operator O i The second score Score2(O i ) can be given by the following formula.
[0126]
number
[0127]
number
[0128] is operator O i It is a set of operators that include and are included in a given set of operators. Each operator O j The first operator, the second operator, and the object type are (as defined above) O i It can be the third operator of the dataset tuple, which is the same as the corresponding tuple. That is, for each j, the third operator O j The first operator / second operator / object type of a tuple having is Oi The first operator / second operator / object type of the corresponding tuple may be the same. In particular, the third operator O j A tuple that has O j It can be defined as the corresponding tuple. j The quantity is the third operator O j It may also be the weight of a tuple having the value Score2(O i ) means that the dataset data is O i If it does not contain the corresponding tuple, it may be a predetermined value (e.g., 0 or 0.1).
[0129] Outputting (S40) may include combining the first score and the second score to obtain a third score for each operator in a given set of operators. Thus, the prediction for one or more operators in a given set of operators may be based on the third score. For example, the prediction may be a single operator corresponding to the highest third score, or several operators ranked by their third scores (e.g., in descending order).
[0130] The combination of the first and second scores may involve different arithmetic operations and may be performed in different ways. For example, the third score of each operator in a given set of operators may be a convex combination of the operator's first and second scores. The weights of the convex combination can represent the importance given to the output of the machine learning function and dataset.
[0131] The joining may involve setting the second score of the operator to a predetermined value (e.g., 0 or 0.1) if such a second score has not been previously defined.
[0132] For example, the third score Score3(O) of operator O in a given set of operators may be given by the following formula:
[0133]
number
[0134] Here, -c and c' are numerical coefficients (e.g., c=2 and c'=3), -Score1(O) is the first score of operator O, -Score2(O) is the second score for operator O.
[0135] To improve the accuracy / usefulness of the prediction, the input data for the machine learning function provided in S30 may further include values that depend on the object cardinality of the selected output connector, for example, a binary value indicating whether the cardinality is 1 or greater than 1. In other words, the prediction can take into account the fact that the data flowing through the selected output connector is rather unique objects or collections of objects. In 2D block programming applications, where such collections are particularly dynamically enabled, this can significantly influence the nature of the operators that the user might want to instantiate next.
[0136] Of the input data provided in S30, the used / internal (e.g., dynamic) object type and / or used / internal (e.g., dynamic) object cardinality (e.g., binary) value may be known for the output connector selected in S20, because the output connector is the output connector of the block node through which the data actually flows, i.e., is evaluated or is evaluable. In such a case, the object type and / or object cardinality value provided in S30 for at least one of the corresponding connectors may be the used / internal (e.g., dynamic) object type and / or the used / internal (e.g., dynamic) object cardinality value, respectively.
[0137] For example, if in S20 the user selects the output of a transform operator block node that is correctly connected and therefore evaluable / evaluable at its input connector, then in S30 the input data provided to the machine learning function, the corresponding tuple of transform operators that can be used to calculate a second score, and therefore the prediction output in S40 may vary depending on the dynamic values of the object type and object cardinality value in the selected output. The prediction may differ in particular if the transform operator block node outputs a unique point, a collection of points, a unique curve, or a collection of curves. All four cases can indeed occur for the same transform operator, depending on whether the block node is input with a unique point, a collection of points, a unique curve, or a collection of curves. The data identifier of the corresponding operator and the data identifier of the corresponding selected connector are the same in all four cases (the identifier of the transform operator and the identifier of the output geometry - the sole output of the transform operator). However, since the user is unlikely to want to perform the same operation on the output in all four cases, all four cases can result in different predictions. For example, if the output is a unique point, the user may want to use it to draw a line in combination with another point. In such a case, the line operator should be expected as the next operator desired by the user. If the output is a collection of points, the user may potentially want to use that collection of points to draw a polyline or spline. Such spline and polyline operators should be expected as the next operators desired by the user in such a case.
[0138] The machine learning function may be a deep learning neural network, e.g., a multilayer perceptron, or alternatively, a transformer network, a graph neural network, or a long-short-term memory (LSTM) network. The machine learning function may contain more than 1 million trainable parameters and / or fewer than 10 million or 5 million trainable parameters. The machine learning function may contain more than 2 layers and / or fewer than 20 layers. Such values allow for reasonable memory consumption and fast evaluation of the machine learning function while achieving high accuracy. Thus, the prediction (S40) (and the resulting representation (S50)) can be performed in real time if the selection is performed in S20. A given set of operators may actually contain more than 50, 100, or 200 different operators and / or fewer than 1000 different operators. Similarly, a given set of object types may contain more than 10, 50, or 100 different object types and / or fewer than 500 different object types.
[0139] By using machine learning and datasets to perform predictions in S40, it becomes possible to avoid calculating statistics for each potential combination, as in the previous example, and then output predictions based on such statistics. The number of potential combinations is particularly large when the given set of operations is large, and as a result, calculating such statistics can be very time-consuming, and storing those values can consume a lot of space. Also, evaluating statistics consumes a lot of time during execution, hindering real-time behavior.
[0140] A machine learning function may be obtained through a training method, which includes obtaining a training dataset containing training examples, and training the machine learning function on the training dataset to minimize the loss over a portion of the training dataset (e.g., 80%) and verify its performance over the remaining portion of the training dataset (e.g., 20%). Training may be performed epoch-by-epoch and / or batch-by-batch according to any machine learning technique adapted to the architecture of the machine learning function (e.g., a multilayer perceptron, a transformer network, a graph neural network, or an LSTM network).
[0141] Each training example includes, as a prediction input (i.e., input to the prediction in S40), an output connector (similar to the one selected in S20), a corresponding geometric block node, a data identifier for the corresponding operator, a data identifier for the output connector, the object type of the output connector, and optionally, a value that depends on the object cardinality of the output connector, for example, a binary value indicating whether the cardinality is 1 or greater than 1, if the result of the machine learning function is input along with such an object cardinality (e.g., binary) value. The training example further includes an operator as a prediction output (ground truth output), associated with such a prediction input (ground truth input). As a result, such offline training may yield a machine learning function configured for online use in S30-S40.
[0142] The training dataset may be obtained by retrieving the corresponding 2D block representations of corresponding (e.g., finished) 3D modeled objects representing the corresponding products to be manufactured, which may have been previously designed by the user (e.g., using the same 2D block representation application) and optionally further manufactured. Such 2D block representations may be retrieved from an internal database and / or a catalog of previously completed and validated designs. Such 2D block representations may be, or include, 2D block representations of multiple previously executed designs represented by the dataset.
[0143] From such extracted 2D block representations, the training method can determine a sequence of design actions, thereby the user (very likely) performing a selection of one output connector from at least one block node, for example, in S20, and then the user instantiates an operator to be connected to the selected output connector, for example, in S60, for example, in S70, for example. The training method can consider such sequences in patterns, each pattern containing an output connector connected to a block node via an arc. Training examples can be appropriately determined from such patterns. Optionally, all such patterns within each retrieved 3D modeled object may be considered and processed at least initially to create at least one training example from each pattern (however, training dataset normalization may then remove some of these examples).
[0144] A pattern may include, for example, an output connector connected to an input connector. Obtaining a training dataset may involve forming a single training example that includes an output connector as a prediction input and an operator represented by block nodes of the input connector as a prediction output.
[0145] Since the patterns are derived from a completed design, each connector in each pattern can be evaluated. Therefore, the training dataset may include, as prediction inputs, the use / dynamic object type and / or use / dynamic object cardinality (e.g., binary) values for each corresponding output connector.
[0146] The training dataset may be normalized to avoid bias in training, or it may be amplified, especially considering the data augmentation described above.
[0147] Returning to the design method in Figure 1, the design method includes displaying (S50) a graphical representation of a list of operators (e.g., less than 10) ranked by their starting score (e.g., a third score or probability) in descending order, based on the prediction output in S40, including at least one operator of the prediction, e.g., at least the most likely operator by prediction, or optionally, the most likely operator by prediction. The display (S50) may be performed in the form of a dialog box and / or a displayed menu showing a list of icons and / or text names for each of the at least one predicted operator. The display (S50) may be performed automatically and / or in real time after the output (S40) is completed, and therefore in real time after the selection in S20, or after a subsequent trigger of the function that initiated the prediction (S30-S40).
[0148] The design method then includes the user selecting an operator from the display in S50 (S60), for example graphically, by clicking or touching the corresponding icon and / or text name. For example, if the user decides to perform a conventional manual search, the operators displayed in S50 may be replaced with newly suggested operators. The search bar may be displayed in the same menu to reduce the number of actions required from the user. However, Figure 1 shows an example where the user selects an operator in S60 from the predictions output in S40.
[0149] Next, the design method may include increasing the weights of corresponding tuples in the dataset by a predetermined number. A corresponding tuple can be defined by a first operator, a second operator, a third operator, and an object type, as described above. The first operator of a corresponding tuple is the corresponding operator represented by the block node of the selected output connector. The second operator of a corresponding tuple is the corresponding operator represented by the preceding block node of the block node of the selected output connector. The third operator of a corresponding tuple is the selected operator. The object type of a corresponding tuple is the object type of the selected output connector. For example, the object type may be the usage / internal object type of the selected output. The predetermined number may be 1, or any value greater than 1, such as 2 or 10. A larger value increases the importance of the selection for the user in the predicted output in S40.
[0150] Increasing the weights of corresponding tuples in a dataset by a predetermined number may also involve generating a new entry in the dataset whenever no data in the dataset contains a corresponding tuple, the new entry having a corresponding tuple as a tuple and a predetermined number (e.g., 1, 2, or 10) as weights.
[0151] This allows the design method to update the dataset after each selection, iteratively learning and adapting to the user's selections. Thus, the design method can always output the user's best prediction, which may differ from another user's best solution in the same context. For example, the design method may include multiple iterations from steps S20 to S120, and after each execution in S60, the design method may include increasing the weights by a predetermined number as described above, thereby obtaining a dataset that represents more of the user's selections in the next iteration in S25.
[0152] The design method then includes adding a block node representing the selected operator to the 2D block representation and thus instantiating the selected operator (S70), and updating the display of the 2D block representation by displaying at least the added block node (S80). The addition (S70) and updating (S80) of the display may be performed automatically and seamlessly in real time once the user's selection (S60) is complete.
[0153] The design method then includes adding an arc between the output connector selected in S20 and the corresponding connector of the block node added in S70 to the 2D block representation, thereby obtaining the updated 2D block representation in S90. Such arc addition may be performed automatically / in real time and seamlessly once the selection (S60) is complete, or it may be performed by the user using the aforementioned drag-and-drop arc creation and positioning technique.
[0154] Next, the design method includes updating the display of the 2D block representation by displaying at least the added arcs (S100). The display update (S100) may be performed automatically / in real time and seamlessly once the addition (S90) is complete. If the design method is automatic from S70 to S90, the display update (S100) may be contiguous / simultaneous and seamless with the display update in S80.
[0155] The design method may optionally include, upon completion of the update (S100), automatically / in real time and seamlessly executing the data flow represented by the arc of the 2D block representation updated in S100 (S110), outputting the thereby updated 3D shape representation, and displaying the updated 3D shape representation simultaneously with the displayed updated 2D block representation (S120). Thus, the design method enables the final update of the 3D shape representation in S120, which provides the user with visual feedback on the edits made via S20 and S60 and optionally S90.
[0156] The design method may be iterated during the design phase and combined with other design steps, for example, following the standard graphical interactive design capabilities of a 3D block representation application, to ultimately produce the complete and accurate shape of the product to be manufactured, for example, allowing the user to add block nodes and arcs in other ways. The 2D block representation and / or 3D shape representation may then be input into the manufacturing process, which may output one or more physical instances of the product manufactured with the exact same shape as the one ultimately achieved at the end of the design phase. Thus, the design method and / or machine learning process may be included in the manufacturing process of the product to be manufactured (e.g., mechanical parts of an assembly of mechanical parts).
[0157] Therefore, design methods generally manipulate modeled objects, particularly 2D block representations and 3D geometric representations. A modeled object is any object defined by data stored, for example, in a database. More broadly, the expression "modeled object" refers to the data itself. Depending on the type of system, modeled objects may be defined by different types of data. A system may, in practice, be any combination of CAD, CAE, CAM, PDM, and / or PLM systems. In these different systems, modeled objects are defined by corresponding data. Thus, we can say CAD objects, PLM objects, PDM objects, CAE objects, CAM objects, CAD data, PLM data, PDM data, CAM data, and CAE data. However, these systems are not mutually exclusive, as modeled objects can be defined by data corresponding to any combination of these systems. Therefore, a system may be both CAD, CAE, PLM, and / or CAM systems, as will become clear from the definitions of such systems provided below.
[0158] A CAD solution (e.g., a CAD system or CAD software) further means any system, software, or hardware at least adapted for designing modeled objects based on their graphical and / or structured representation (e.g., a feature tree), such as CATIA. In this case, the data defining the modeled object includes data that enables the representation of the modeled object. A CAD system can provide a 3D geometric representation of a CAD modeled object, for example, using edges or lines, and in specific cases, faces or surfaces. Lines, edges, or surfaces can be represented in various ways, for example, by non-uniform rational B-splines (NURBS). Specifically, a CAD file contains specifications from which geometry can be generated, thereby generating a representation. The specifications of a modeled object can be stored in a single CAD file or multiple CAD files. The typical size of a file representing a modeled object in a CAD system is in the range of 1 megabyte per part. Also, a modeled object can typically be an assembly of thousands of parts. The specifications of a CAD model (also called "CAD specifications") may be stored in a CAD file as described above, but may also be stored as distributed CAD data in one or more storage environments, i.e., a cloud environment.
[0159] In the context of CAD, a modeled object can typically be a 3D modeled object representing a product, such as a part or an assembly of parts, or in some cases, an assembly of a product. A 3D modeled object can also be a product. "3D modeled object" means any object that is modeled by data that enables its 3D shape representation. A 3D shape representation allows a part to be viewed from all angles. For example, when a 3D modeled object is represented in 3D, it can be handled and rotated around any of its axes, or around any axis in the screen on which the representation is displayed. This, in particular, excludes 2D icons that are not 3D modeled. Displaying 3D shape representations facilitates design (i.e., increases the speed at which designers statistically accomplish those tasks). This speeds up the manufacturing process in industry, as product design is part of the manufacturing process.
[0160] 2D block representations and corresponding 3D geometric modeling objects may represent, for example, the geometric shapes of products manufactured in the real world after virtual design is completed using CAD / CAE software solutions or CAD / CAE systems, such as (e.g., mechanical) parts or assemblies of parts (or equivalently, assemblies of parts, which may be considered parts themselves from the perspective of design methods, or design methods may be applied independently to each part of the assembly), or more generally, any rigid body assembly (e.g., a movable mechanism). CAD / CAE software solutions enable the design of products in a wide range of unrestricted industrial sectors, including aerospace, architecture, construction, consumer goods, high-tech devices, industrial equipment, transportation, marine, and / or offshore oil / gas production or transportation. Therefore, a 3D modeled object designed by the design method may represent an industrial product that could be any mechanical part, such as parts of ground vehicles (e.g., including automobiles and light truck equipment, racing cars, motorcycles, trucks and motor equipment, trucks and buses, and trains), parts of aircraft (e.g., including airframe equipment, aerospace equipment, propulsion equipment, defense products, airline equipment, and space equipment), parts of naval vehicles (e.g., including naval equipment, commercial ships, offshore equipment, yachts and workboats, and marine equipment), general mechanical parts (e.g., including industrial manufacturing machinery, large mobile machinery or equipment, installed equipment, industrial machine products, processed metal products, and tire products), electromechanical or electronic components (e.g., including household appliances, security and / or control and / or instrumentation products, computing and communication equipment, semiconductors, medical devices and equipment), consumer goods (e.g., including furniture, household and garden products, leisure goods, fashion products, hard goods retail products, and soft goods retail products), and packaging (e.g., including food and beverages and tobacco, beauty and personal care, and household product packaging).
[0161] 3D shape representation may also be B-rep. The 3D shape of a part displayed on a computer screen when a modeled object is represented may be B-rep (for example, B-rep tessellation).
[0162] A PLM system further refers to any system adapted to the management of modeled objects that represent physical products. Therefore, in a PLM system, modeled objects are defined by data suitable for manufacturing physical objects. These may typically be dimensional values and / or tolerance values. Having such values is actually better for the accurate manufacturing of the object.
[0163] A CAE solution is any solution, including both hardware and software, adapted for the analysis of the physical behavior of modeled objects. A well-known and widely used CAE technique is the finite element model (FEM), which will hereafter be referred to as a CAE model. FEM typically involves dividing a modeled object into elements, i.e., a finite element mesh, whose physical behavior can be calculated and simulated through equations. Such CAE solutions are offered by Dassault Systèmes under the trademark SIMULIA®. Another emerging CAE technique involves modeling and analyzing complex systems consisting of multiple components from different fields of physics, without CAD geometry data. CAE solutions enable simulation, and therefore, optimization, improvement, and verification of products to be manufactured. Such CAE solutions are offered by Dassault Systèmes under the trademark DYMOLA®. Using CAE, it is possible to ensure that various structural requirements (but not limited to mass, stiffness, strength, durability, etc.) are achieved by a new CAD model. Some of these requirements are sometimes called key performance indicators (KPIs). For many industrial products (e.g., automobiles, airplanes, consumer packaging, high-tech), these KPIs are in conflict; for example, lower mass usually leads to lower stiffness. Therefore, optimization methods are often applied to find the best trade-off between KPIs.
[0164] A CAM solution refers to any solution, hardware, or software adapted to manage product manufacturing data. Manufacturing data generally includes data about the product being manufactured, the manufacturing process, and the necessary resources. CAM solutions are used to plan and optimize the entire product manufacturing process. For example, a CAM solution can provide a user with information about feasibility, the duration of the manufacturing process, or the number of resources, such as specific robots, that may be used at a particular step of the manufacturing process, thus enabling decisions about management or necessary investments. CAM is a subsequent process following the CAD process and potential CAE processes. For example, a CAM solution can provide information about machining or forming parameters consistent with the extrusion features provided in the CAD model. Such CAM solutions are offered by Dassault Systèmes under the trademarks CATIA, Solidworks, or DELMIA®.
[0165] Therefore, CAD and CAM solutions are closely related. In fact, CAD solutions focus on designing a product or part, while CAM solutions focus on how to make it. Designing a CAD model is the first step towards computer-aided manufacturing. Indeed, CAD solutions provide crucial features such as feature-based modeling and boundary representation (B-Rep) to reduce the risk of errors and loss of precision during the manufacturing process handled by CAM solutions. In reality, the CAD model is intended to be manufactured. Therefore, a 3D modeled object is a virtual twin, also called a digital twin, of the object to be manufactured, serving two purposes: - Checking the correct behavior of manufactured objects in a specific environment, - To ensure the manufacturability of the manufactured object and It has.
[0166] PDM stands for Product Data Management. A PDM solution refers to any solution, hardware or software, adapted to manage all types of data related to a particular product. PDM solutions can be used by all stakeholders involved in the product lifecycle, primarily engineers, but also project managers, finance personnel, sales personnel, and buyers. PDM solutions are generally based on a product-oriented database. This allows actors to share consistent data about their product and thus prevents actors from using different data. Such PDM solutions are offered by Dassault Systèmes under the trademark ENOVIA®.
[0167] The 3D modeled objects output by the design method may be, for example, CAD models that include or consist of feature trees and / or B-reps. Such models may originate from CAE models and may arise from a conversion process from CAE to CAD and 2D block representations, which the design method may include, for example, in its initial stages.
[0168] The design method may be included in the manufacturing process, and the manufacturing process may include, after performing the design method, manufacturing a physical product corresponding to the 3D modeled object by the design method. The manufacturing method consists of the following steps: - Applying a design method and obtaining a 3D object (CAD model) output by the design method, - To manufacture parts / products, use the acquired CAD model. It may include.
[0169] Using a CAD model for manufacturing refers to any real-world action or set of actions that involve or participate in the manufacturing of the product / part represented by the CAD model. Using a CAD model for manufacturing includes, for example, the following steps: - Editing the acquired CAD model, - Performing simulations (e.g., structural simulations, thermodynamic simulations, aerodynamic simulations) to verify mechanical properties, usage properties, and / or manufacturing properties, and / or constraints based on a CAD model or a corresponding CAE model (e.g., a CAE model from which the CAD model originates after a CAE-to-CAD conversion process), and - Editing the CAD model based on the simulation results, -Optionally (i.e., depending on the manufacturing process used, the production of mechanical products may or may not include this step), to determine (e.g., automatically) manufacturing specifications / CAM specifications (e.g., stored as manufacturing files / CAM files or as distributed CAM data stored in one or more storage devices) based on (e.g., edited) CAD models for the production / manufacturing of the product, - Sending CAD specifications and / or manufacturing specifications / CAM specifications to the factory, - To produce / manufacture (e.g., automatically) a mechanical product originally represented by a model output by a design method, based on determined manufacturing specifications / CAM specifications or CAD models, which may include (e.g., automatically) supplying the manufacturing specifications / CAM specifications and / or CAD specifications to a machine that performs the manufacturing process. It may include.
[0170] This final step in production / manufacturing is sometimes called the manufacturing step or production step. This step manufactures / produces a part / product based on a CAD model and / or CAM specification, for example, once the CAD model and / or CAD specification is supplied to one or more manufacturing machines or computer systems that control the machines. The manufacturing step may include performing any known manufacturing process or a set of manufacturing processes, for example, one or more additive manufacturing steps, one or more cutting steps (e.g., laser cutting or plasma cutting steps), one or more punching steps, one or more forging steps, one or more bending steps, one or more deep drawing steps, one or more forming steps, one or more machining steps (e.g., milling steps), and / or one or more punching steps. This design method improves the design of the model (CAE or CAD) representing the part / product, and thus improves manufacturing and its productivity.
[0171] Editing a CAD model may involve a user (i.e., a designer) performing one or more edits on the CAD model, for example, by using a CAD solution. Modifications to a CAD model may include corresponding one or more modifications to the geometry and / or parameters of the CAD model. Modifications may include any or a set of modifications performed on the model's feature tree (e.g., modifications to feature parameters and / or specifications) and / or modifications performed on the displayed representation of the CAD model (e.g., B-rep). Modifications are those that maintain the technical functionality of the part / product; that is, the user may affect the geometric shape and / or parameters of the model, but the modification is performed solely for the purpose of making the CAD model more technically compliant with the downstream use and / or manufacture of the part / product. Such modifications may include any or a set of modifications that make the CAD model technically compliant with the specifications of machinery used in downstream manufacturing processes. Such modifications may additionally or alternatively include any or a set of modifications that make the CAD model technically compliant with further use of the manufactured product / part, such modifications or a set of modifications may be based, for example, on the results of a simulation.
[0172] The CAM specification may include a manufacturing step-up model derived from the CAD model. The manufacturing step-up may include all the data necessary to manufacture the mechanical product such that the mechanical product has the geometry and / or material distribution corresponding to what is captured by the CAD model, possibly including manufacturing tolerances. Determining the production specification may include applying any CAM (computer-aided manufacturing) or CAD-to-CAM solution (e.g., any automated CAD-to-CAM conversion algorithm) to determine the production specification from the CAD model (e.g., automatically). Such a CAM or CAD-to-CAM solution is a software solution that enables the automatic generation of manufacturing instructions and tool paths for a given manufacturing process based on the CAD model of the product to be manufactured, namely, -Fusion360, -FreeCAD, -CATIA, -SOLIDWORKS, - Dassault Systèmes' NC Shop Floor programmer, as shown at https: / / my.3dexperience.3ds.com / welcome / fr / compass-world / rootroles / nc-shop-floor-programmer - Dassault Systèmes' NC Mill-Turn Machine Programmer, as shown at https: / / my.3dexperience.3ds.com / welcome / fr / compass-world / rootroles / nc-mill-turn-machine-programmer, and / or -Dassault Systèmes' Powder Bed Machine Programmer, as shown at https: / / my.3dexperience.3ds.com / welcome / fr / compass-world / rootroles / powder-bed-machine-programmer It may include one or more of the following.
[0173] The product / part may be an additively manufactured part, i.e., a part manufactured by additive manufacturing (i.e., 3D printing). In this case, the production process does not include a step of determining CAM specifications and proceeds directly to the production / manufacturing steps by directly (e.g., automatically) supplying the CAD model to the 3D printer. The 3D printer is configured to directly and automatically 3D print the mechanical product according to the CAD model when it is supplied with a CAD model representing the mechanical product (e.g., when 3D printing is started by the 3D printer operator). In other words, the 3D printer receives the CAD model supplied to it (e.g., automatically), reads the CAD model (e.g., automatically), and prints the part (e.g., automatically) by adding the material together, for example, layer by layer, to reproduce the geometric shape and / or distribution of the material captured by the CAD model. The 3D printer adds the material and thereby reproduces the geometric shape and / or distribution of the material captured by the CAD model with actual accuracy, with or without discretionary tolerance errors and / or manufacturing corrections, up to the resolution of the 3D printer. Manufacturing may include determining such manufacturing corrections and / or tolerance errors, for example, by the user (e.g., the operator of the 3D printer) or automatically (by the 3D printer or the computer system controlling it), for example, by modifying the CAD specifications to match the specifications of the 3D printer. The manufacturing process may additionally or alternatively include, from the CAD model, (e.g., automatically by the 3D printer or the computer system controlling it) determining the printing orientation to minimize overhang volume (as described in European Patent No. 3327593 incorporated herein by reference), layer slicing (i.e., determining the thickness of each layer, as well as the path / trajectory for each layer, and other characteristics of the 3D printer head (e.g., in the case of a laser beam, for example, path, velocity, intensity / temperature, and other parameters)).
[0174] Alternatively, the product / part may be a machined part (i.e., a part manufactured by machining), such as a milled part (i.e., a part manufactured by milling). In such cases, the manufacturing process may include a step of determining the CAM specification. This step can be performed automatically by any suitable CAM solution for automatically obtaining the CAM specification from a CAD model of the machined part. Determining the CAM specification may include checking (e.g., automatically) whether the CAD model has any geometric peculiarities (e.g., errors or artifacts) that could affect the manufacturing process, and correcting such peculiarities (e.g., automatically). For example, machining or milling based on the CAD model may not be performed if the CAD model still contains sharp edges (because the machining or milling tools cannot create sharp edges), in which case determining the CAM specification may include rounding or filleting (e.g., automatically) such sharp edges (e.g., with a rounding or filleting radius substantially equal to the tolerance, e.g., corresponding to the radius of the cutting head of the machining tool) so that machining or milling based on the CAD model can be performed. More generally, determining CAM specifications may automatically include rounded or filleted shapes in a CAD model that do not conform to the radius of the machining or milling tool in order to enable machining / milling. This check and possible correction (e.g., rounding or filleting of geometric shapes) may be performed automatically as described above, but may also be performed manually by a user (e.g., a machining engineer) on a CAD and / or CAM solution, e.g., a solution that restricts the user to perform corrections to make the CAD model conform to the specifications of the tool used in the machining process.
[0175] In addition to checks, determining the CAM specification may include determining the machining or milling path, i.e., the path that the machining tool should take to machine the product (e.g., automatically). The path may include a set of coordinates and / or parameterized trajectories that the machining tool should follow for machining, and determining the path may include calculating these coordinates and / or trajectories (e.g., automatically) based on the CAD model. This calculation may be based on the calculation of the Minkowski subtraction boundary of the CAD model by the CAD model representation of the machining tool, as discussed, for example, in European Patent Application No. 21306754.9 filed by Dassault Systèmes on 13 December 2021 and incorporated herein by reference. The path may be a single path, for example, understood to be followed continuously by the tool without interruption of contact with the material being cut. Alternatively, the path may be a series of subpaths followed in a specific order by the tool, for example, each continuously followed by the tool without interruption of contact with the material being cut. Optionally, determining the CAM specifications may include (e.g., automatically) setting machine parameters, including cutting speed, cutting / drilling height, and / or die opening stroke, based on the determined path and machine specifications. Optionally, determining the CAM specifications may then include (e.g., automatically) configuring nesting so that the CAM solution determines the best orientation of the part to maximize machining efficiency.
[0176] In the case of machined or milled parts, the determination of the CAM specification therefore results in and outputs a CAM specification including the machining path, as well as the optionally set machine parameters and / or configured nesting. This outputted CAM specification may then be fed (e.g., directly and automatically) to the machining tool, and / or the machining tool may then be programmed (e.g., directly and automatically) by reading the specification, in which case the production process includes production / manufacturing steps in which the machine performs machining of the product according to the production specification, for example, by directly and automatically executing the production specification. The machining process includes the machining tool cutting a real-world block of material to reproduce the geometric shape and / or distribution of the material captured by the CAD model, for example, to tolerances (e.g., tens of microns in the case of milling).
[0177] Alternatively, the product / part may be a molded part, i.e., a part manufactured by molding (e.g., injection molding). In such cases, the manufacturing process may include a step of determining the CAM specifications. This step may be performed automatically by any suitable CAM solution for automatically obtaining the CAM specifications from a CAD model of the molded part. Determining the CAM specifications may include performing a series of molding checks (e.g., automatically) based on the CAD model to check that the geometric shape and / or distribution of the material captured by the CAD model is suitable for molding, and performing appropriate corrections (e.g., automatically) if the CAD model is not suitable for molding. Performing checks and appropriate corrections (if any) may be performed automatically or alternatively by the user (e.g., a molding engineer) using a CAD and / or CAM solution that allows the user to perform appropriate corrections to the CAD model but restricts the user's corrections to conform the CAD model to the specifications of the molding tool. The checks may include verifying that the virtual product represented by the CAD model matches the dimensions of the mold, and / or verifying that the CAD model includes all the draft angles necessary to demold the product as is known by itself from molding. Next, determining the CAM specification may further include determining the amount of liquid material to be used for molding and / or the time for the liquid material to cure / solidify in the mold, based on the CAD model, and outputting a CAM specification containing these parameters. The production process then includes performing molding (e.g., automatically) based on the output specification, in which the mold molds the liquid material for the determined curing time into a shape corresponding to the geometric shape and / or distribution of the material captured by the CAD model, for example, up to tolerance (e.g., incorporating or modifying a draft angle for demolding).
[0178] Alternatively, the product / part may be a press-formed part, also sometimes called a “stamped part,” i.e., a part manufactured by a press-forming process. In this case, the manufacturing process may include determining CAM specifications (e.g., automatically) based on a CAD model. The CAD model represents the stamped part, and may be represented, for example, with one or more flanges if the part has flanges, and in the latter case, with the excess material to be removed to form the unfolded state of one or more flanges of the part, as is well known in stamping. Thus, the CAD model includes a portion representing the part without flanges (and possibly the entire part), an outer extra patch portion representing the flanges (if any), and possibly extra material (if any). This extra patch portion can present g2 continuity over a certain length, and then g1 continuity over a certain length.
[0179] Determining the CAM specifications in this stamping process may include determining the parameters of the stamping machine, e.g., the size of the stamping die or punch and / or the stamping force (e.g., automatically), based on the geometric shape and / or distribution of the material of the virtual product captured by the CAD model. If the CAD model also includes a representation of excess material to be removed to form the unfolded state of one or more flanges of the part, the excess material to be removed may be cut by machining, for example, and determining the CAM specifications may also include determining the corresponding machining CAM specifications, as described above. If one or more flanges are present, determining the CAM specifications may include determining the geometric specifications of the g2 continuity portion and the g1 continuity portion, which, in the bending process after the stamping itself and the removal of excess material, allow the flanges to be bent along the g2 continuity length toward the inner surface of the stamped part. Therefore, the resulting CAM specifications may include stamping tool parameters, optional specifications for bending the flange (if any), and optional machining manufacturing specifications for removing excess material (if any).
[0180] Next, the stamping manufacturing process can output CAM specifications, for example, directly and automatically, and execute the stamping process based on the specifications (for example, automatically). The stamping process may include stamping (e.g., punching) a portion of the material to form a product as represented by the CAD specifications, which may have an unfolded flange and excess material (if any). Where appropriate, the stamping process may include cutting off excess material based on machining manufacturing specifications and folding the flanges based on the above specifications for folding the flanges, thereby folding the flanges to their g2 continuous length and giving the outer boundary of the part a smooth appearance. In the latter case, the shape of the manufactured part, once produced, differs from its virtual counterpart represented by the CAD model in that the excess material has been removed and the flanges are folded, whereas the CAD model represents the part in a state where the excess material and flanges are not folded.
[0181] A computer system may include a processor coupled with memory and a graphical user interface (GUI), where memory stores computer programs containing instructions for performing training and / or design methods. Memory may also store databases. Memory is any hardware adapted for such storage and may include several physically separate parts (e.g., one for programs, and possibly one for databases).
[0182] Figure 2 shows an example of a system, where the system is a client computer system, such as a user's workstation.
[0183] The client computer in this example comprises a central processing unit (CPU) 1010 connected to an internal communication bus 1000, and random access memory (RAM) 1070 also connected to the bus. The client computer further comprises a graphics processing unit (GPU) 1110 associated with video random access memory 1100 connected to the bus. The video RAM 1100 is also known in the art as a frame buffer. A mass storage device controller 1020 manages access to mass storage devices such as a hard drive 1030. Mass memory devices suitable for tangibly embodying computer program instructions and data include all forms of non-volatile memory, including, for example, semiconductor memory devices such as EPROMs, EEPROMs, and flash memory devices, magnetic disks such as internal hard disks and removable disks, and magneto-optical disks. Any of the foregoing may be complemented by or incorporated into a specially designed ASIC (Application-Specific Integrated Circuit). A network adapter 1050 manages access to the network 1060. The client computer may also include a cursor control device, a tactile device 1090 such as a keyboard. A cursor control device is used within a client computer to allow the user to selectively position the cursor at any desired location on the display 1080. Furthermore, the cursor control device allows the user to select various commands and input control signals. The cursor control device includes a number of signal generating devices for input control signals to the system. Typically, the cursor control device may be a mouse, and the mouse buttons are used to generate signals. Alternatively or additionally, the client computer system may include a sensing pad and / or a sensing screen.
[0184] A computer program may include instructions that can be executed by a computer, and the instructions include means for causing the system to execute the design method. The program may be recordable on any data storage medium, including the system's memory. The program may be implemented, for example, in digital electronic circuits, or in computer hardware, firmware, software, or a combination thereof. The program may be implemented as a product tangibly embodied in a device, for example, a machine-readable storage device for execution by a programmable processor. The steps of the method may be executed by a programmable processor that executes a program of instructions for performing the functions of the method by acting on input data and producing outputs. Thus, the processor may be programmable and coupled to receive data and instructions from a data storage system, at least one input device, and at least one output device, and to transmit data and instructions to the 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 code as needed. In any case, the language may be a compiled language or an interpreted language. The program may be a full installment program or an update program. The application of a program to a system, in any case, provides instructions for executing the method. Alternatively, the computer program may be stored and executed on a server in a cloud computing environment that communicates with one or more clients over a network. In such a case, a processing unit executes the instructions contained in the program, thereby causing the method to be executed on the cloud computing environment.
[0185] Next, the implementation will be explained with reference to Figures 3 to 25.
[0186] The implementation provides a solution for proposing functions in applications characterized by representing operator connections in a graph-like form, i.e., in the form of a 2D block representation. An example of such an application is xGenerative Design, part of the CATIA portfolio, a web application that combines 3D and visual scripting modeling based on a 2D block representation. However, this solution may be adapted to propose functions in feature tree-based applications such as feature tree-based CATIA.
[0187] Figure 3 shows a screenshot of the interface of such a 2D block programming application.
[0188] Such an application can simultaneously display a 3D shape representation 300 of a 3D modeled object representing a product (for example, a folded alveolar sheet structure in this case) and a 2D block representation 310 of the 3D modeled object. The 2D block representation 310 includes block nodes 320, which may optionally all be rectangles parallel to the screen; input connectors 322, which may be dot shapes displayed on the left boundary side of the corresponding block node 320; output connectors 324, which may be dot shapes displayed on the right boundary side of the corresponding block node 320; and arcs 326, which connect the output connectors 324 of the first block node to one or more input connectors 322 of another second block node 320. The application can also display menus and menu buttons 330 and widgets 340.
[0189] The application enables generative 3D modeling through a library that can be instantiated or a predetermined set of operators. Operators are configured to handle geometric operations (Point, Line, Curve, Surface, Extrude, Rotate, Mesh, etc.), mathematical operations (addition, division, etc.), list management, and more.
[0190] The library can suggest over 500 operators, and that number may be increasing. As a result, finding the appropriate operator at a particular design stage can be difficult for the user. The proposed solution addresses the discoverability problem.
[0191] Referring to Figure 4, an operator is a node in a virtual graph. The figure shows an instance of a Point By Coordinates node. On the left side of the figure, the node is not selected by the user, and only its input connector 322 and its output connector 324 are visible to the user. On the right side of the figure, the node is selected, and additional data fields 400, a menu 410, and information 420 are displayed to the user. The right portion of the figure shows the view of the node when it is selected by the user (e.g., by a mouse click) to allow modification of input values, management of node state, etc., and the operator processes input data and provides output results through internal operations (geometric transformations, formulas, data structure management, etc.). In the example in Figure 4, the "Point By Coordinates" operator / node takes three lengths as coordinates and constructs a geometric point (named "Point.1" here) from them.
[0192] Referring to Figure 5, the nodes are connected via Arc 326 through input and output connectors, thus forming a virtual graph. The figure shows how the "pt" input connector of the "coordinates" block node is connected to the output of the point operator by coordinates. In this simple example, the user connects the previous point to the "Coordinates" node to obtain the point coordinates. "coordinates" forms an example of an operator with several outputs.
[0193] Referring to Figure 6, the application can finely control data types, and the data within input connectors and the data passing through / flowing between nodes are typed to define their properties and ensure compatibility (compliance) between output and input connectors. The figure shows an example of the "line from two points" operator, where the user generates a line (line segment) using two points. To enable this, each input connector has a specific static object type to specify what kind of data can be connected to it. -pt1 and pt2 are of type "GeometricPoint" and expect geometric points. -st and end are the optional extension lengths of a line that extends beyond two points, and they are of type "Length". -sup is an optional surface support for lines on which lines can be drawn. This is of type "GeometricSurface".
[0194] Referring to Figure 7, if the connection is incorrect in terms of type, the node may be in an error state, and a visual warning may be displayed to the user. In this example, length is connected as the second point of the line. The types "Length" and "GeometricPoint" are incompatible, the node is in an "Error" state, and line generation is impossible.
[0195] Figures 8 and 9 show examples of generated lines with two points and two extension lengths, including the 2D block representation (or graph view) in Figure 8 and the 3D shape representation (or 3D view) in Figure 9.
[0196] Referring to Figure 10, in the prior art, the user can select one node, and by pressing the spacebar, a search menu for further connections appears. Here, the node "Point.1" is selected. This disclosure addresses the problem of applications that suggest to the user an appropriate set of operators for connecting the selection. Without intelligent processing, calculating the number of suggestions while maintaining the responsiveness of the application can be difficult.
[0197] In situations where many operators exist, the proposed solution and its implementation provide a way to help the user find the operator they are looking for as quickly as possible, select the correct function for use in a defined context within the application, and do so in the most optimized and efficient way possible using artificial intelligence (e.g., deep learning) and datasets corresponding to previously made selections (e.g., by the user and / or other users).
[0198] Based on user selection and the user-designed 2D block representation, the proposed solution and its implementation allow for the suggestion of a suitable ranked list of operator proposals based on relational tree probabilities represented by machine learning / deep learning methods and datasets. Operators allow manipulation of any type of data (geometric, mathematical, images, etc.) via mathematical functions that transform inputs into outputs. In implementation, these data are considered in making these proposals. This improves the discoverability and accessibility of the operators.
[0199] Therefore, this implementation provides suggestions based on what the deep learning model observed during training on different graph operator examples and a dataset that may represent previous user choices. This allows for suggestions that take into account the user's experience in previous operator creation in 2D block representations, which helps improve the accuracy of these suggestions. Furthermore, the roles of the deep learning model and the dataset are complementary; the deep learning model allows the user to discover a set of operators and guide operators during design. The dataset, on the other hand, represents the frequency of operator usage and adapts to the user's choices over time. Thus, the use of the dataset makes it possible to output predictions that are particularly tailored to the user. For example, a novice user may be guided by the deep learning model and dataset based on several "default" previously run designs that predict the most popular operators to be used. An intermediate user can discover the strength of customization in the design method over time. The dataset can adapt to the behavior of expert users, thereby predicting each expert user's specific design habits. In this way, the design method can be beneficial for all users, giving general and popular choices in the absence of specific personalization, and the results can adapt to the user's behavior over time.
[0200] In particular, training deep learning models may require a data normalization step to obtain optimal model performance. The dataset can track loss information during normalization by highlighting the most common operators.
[0201] Referring to Figure 11, the design method and implementation can be based on the concept of relational tree probability. Relational tree probability can be a tree with dedicated nodes, i.e., a predecessor node (e.g., a second operator), a node (e.g., a first operator), a type (e.g., an object type), and a target (e.g., a third operator). The tree can include links from predecessor nodes to nodes, links from nodes to types, and links from types to targets. Such links may indicate relationships between the first, second, and third operators and the object type. Each level of the tree can have its own role. For example, predecessor nodes and types can enable a semantic approach. Nodes may indicate working nodes.
[0202] Figure 12 shows an example of a 2D block representation.
[0203] Node 501 outputs the character "c". Node 501 is the input to both nodes 521 and 522. Nodes 521 and 522 convert the character "c" received as input into a 3D character. Node 521 has a modifier 511 as input indicating that the "fill" option is active, and node 522 has a modifier 512 as input indicating that the "fill" option is not active. Therefore, the output object types of nodes 521 and 522 are different. Specifically, the output of node 521 is a filled 3D geometric object, and the output of node 522 is a 2D geometric object. The outputs of nodes 521 and 522 are connected to the "Domain" operators 531 and 532, respectively. The outputs of nodes 531 and 532 are connected to the "Extrude" operators 541 and 542, respectively. Therefore, both block nodes 541 and 542 represent the same operator and are connected to the same input operator "Domain". However, their inputs have different object types: "Geometric Volume" for block node 541 and "Geometric Surface" for block node 542. The outputs can be visualized in block nodes 551 and 552, respectively. The outputs of block nodes 541 and 542 may be connected to different operators, for example, the operator "Slice Volume" 561 for block node 541 and the operator "Slice Surface" 562 for block node 542.
[0204] Figure 13, shown in Figure 12, represents a tree of possible choices of operators and object types corresponding to relational tree probabilities. Specifically, the "Domain" operator (e.g., the preceding node in Figure 11) can be connected to the "Extrude" operator (e.g., the node in Figure 11), which can be connected to the object type (e.g., the type in Figure 11) "Geometric Volume" or "Geometric Surface," depending on the object type received as input. The object type "Geometric Volume" can be connected to the operator (e.g., the target in Figure 11) "Slice Volume" or "Fillet." The object type "Geometric Surface" can be connected to the operator (e.g., the target in Figure 11) "Slice Surface" or "Offset Surface."
[0205] Figures 14–20 demonstrate the implementation of the generation method and provide screenshots and diagrams showing how the dataset acquired in S25 can be updated in real time as the user designs an object.
[0206] Figure 14 shows an example of a 2D block representation. The output of node 600, which represents "Line.2", is connected to block 610, which represents the operator "Extrude.8". The user selects the output connector of operator 610 (in S20). A graphical representation 620 of the five operators is displayed.
[0207] Figure 15 shows a relational tree. The preceding node is the operator "LinePtDir", the node is the operator "Extrude", and the type is "Geometric Surface". The relational tree further contains leaves corresponding to each of the possible options (shown, for example, in S50). In Figure 15, two possible options, "Center" and "Thick Surface", are shown, corresponding to the top two prediction options of proposal 620 in Figure 14.
[0208] Figure 16 shows a portion of the dataset obtained in S25. This portion includes rows, each containing a tuple and weights. Each tuple has "LinePtDir" as its second operator, "Extrude" as its first operator, and "Geometric Surface" as its type. The target operator of the tuple changes, as do the relative weights, to correspond to different instantiations of the tuple in the previous design.
[0209] Figure 17 illustrates the effect of the user's first selection. The user selected the operator "Extremum" as an option for the graphical representation 620. Since such an operator was not among the top five, it was not displayed. Therefore, a new node 640 representing the operator "Extremum.1" is created and connected to node 610. The dataset is updated accordingly. For example, the weight of the row shown in Figure 16, which has "Extremum" as the target operator, can be increased from 4 to 5. When the user selects the output connector of node 610 again, the graphical representation 621 of the five operators is displayed again. The graphical representation 621 includes the identification 650 of the operator "Extremum". The fact that the operator "Extremum" is visible in 621 but not in 620 reflects the increase in the relative tuple weight and demonstrates the effectiveness of the design method and implementation.
[0210] Figure 18 shows the effect of the user selecting the operator "Extremum" as an option again. A new node 641 representing the operator "Extremum.2" is created. The dataset is updated accordingly, and for example, the weight of the row shown in Figure 16 with "Extremum" as the target operator may increase from 5 to 6. When the user selects the output connector of node 610 again, the graphical representation 622 of the five operators is displayed again. The graphical representation 622 includes the identification 650 of the operator "Extremum". The fact that the identification of the operator "Extremum" is higher in the graphical representation in 622 compared to 621 reflects the increase in the relative tuple weight and further demonstrates the effectiveness of the design method and implementation.
[0211] Figures 19 and 20 show how the code behind the graphical representation is updated. In Figure 19, the operator "Extremum" is at position 4 and has a score of approximately 0.13 (e.g., the third score). After the user selects the operator "Extremum" multiple times, the relative tuple weight increases, and the score (e.g., the third score) increases. This effect can be seen in Figure 20, where the operator "Extremum" has a weight of approximately 0.20.
[0212] After some design work, the dataset contains several data points, each reflecting a user's choice. This makes the dataset larger and uniquely reflects the user's choices and preferences.
[0213] Figure 21 shows an example of a dataset obtained in S25. Each row in Figure 21 corresponds to a portion of the dataset data, including tuples and weights (called counts in Figure 21). The first column, "Antecedent," corresponds to the second operator of the tuple. The second column, "Node," corresponds to the first operator of the tuple. The third column, "Type," corresponds to the object type of the tuple. The fourth column, "Target," corresponds to the third operator of the tuple.
[0214] In this implementation, the resulting neural network may be a multilayer perceptron.
[0215] Referring to Figure 22, the neural network model (deep learning model) may be a multilayer perceptron having the architecture shown in the figure. The implemented neural network model was trained on a training dataset built using a previously completed 3D design (e.g., using CATIA xGenerative Design).
[0216] Figure 23 shows the extracted training dataset obtained in this way, with each row corresponding to a training pattern. In the leftmost column, the figure shows the target / selected node (i.e., the ground truth operator, i.e., the predicted output), in other words, the result that the AI model must aim for. The other columns represent the predicted input data described in the previous section, simulating selections from the user. For example, the first row is a mono selection of a "Sequence" node (which creates a sequence of numbers) with an output called "createdList" containing a list of elements. In this situation, the user has selected / connected the node CurveEditor.
[0217] Figure 24 shows an example of a 2D block representation that may correspond to the first row described above.
[0218] Training datasets extracted from existing designs may be uneven in the number of examples, which can affect prediction accuracy due to biased training. In implementation testing, one class may have over 100 examples, while another class may have fewer than 5. Ideally, training should have an equal number of examples for each class. Given this, data normalization aims for a fixed initial number of examples per class (e.g., 40), discarding examples in classes that initially have more than this fixed number, and duplicating examples in classes that have fewer than this fixed number, until the target is reached.
[0219] Neural networks can take scalar values (numbers) as input data. Therefore, dataset creation can involve transforming the data into a format that fits the model. This can be done through indexing. In a separate index, dataset creation can associate operators and connectors (inputs and outputs) with numbers and pass them to the AI model.
[0220] Figure 25 shows an excerpt of the indexing of operator output connectors, with the index in the left column and the operator / connector name in the right column. For example, the output "zx" of the operator "RefElements" (which gives the canonical planes - xy, yz, zx - and the origin - O - in 3D space) has index 1. The AI model is given "1" to represent "RefElements|zx".
[0221] Once the design has been processed and the index has been generated, training of the model can begin. Training can involve providing input data and observing the output predictions. Training can then compare these predictions to the desired outcome associated with this input and use gradient descent and softmax functions to adjust the weights of the deep learning model to converge to the final correct outcome.
[0222] The API allows you to integrate the model into your application by extracting user selection information, using it to make predictions, and finally showing the predicted suggestions to the user.
Claims
1. A computer implementation method for designing a 3D model object representing a product to be manufactured, By computer systems, The 3D shape representation of the aforementioned 3D modeled object, The 2D block representation of the aforementioned 3D model object and The 2D block representation is to display the two simultaneously, and the 2D block representation is It is a block node, Each block node represents a corresponding operator in a predetermined set of operators, each operator in the predetermined set of operators has a corresponding data identifier, each operator in the predetermined set of operators further has one or more inputs and outputs, each input of each operator has a corresponding data identifier, and each output of each operator has a corresponding data identifier. For at least one block node, the output of the corresponding operator represented by the at least one block node is a corresponding set of one or more geometric objects. The output of the operator has dynamic object cardinality, and at least one input of the operator has dynamic object cardinality. The output of the operator has an object type, and optionally, the object type of the output of the operator is dynamic, in which case at least one input of the corresponding operator has a dynamic object type, a block node and One or more input and output connectors on each corresponding block node, Each input connector represents the corresponding input of the corresponding operator represented by the corresponding block node, The output connector comprises one or more input and output connectors that represent the output of the corresponding operator represented by the corresponding block node, An arc between the output connector of the first block node and the corresponding input connector of the second block node, Each arc includes an arc representing the data flow from the output connector of the first block node to the corresponding input connector of the second block node, The 2D block representation is configured such that the execution of the data flow represented by the arc of the 2D block representation outputs the 3D shape representation. The user, interacting graphically with the 2D block representation, selects one output connector from the at least one block node (S20), wherein the block node of the selected output connector has a preceding block node. The aforementioned computer system, Obtaining a pre-trained machine learning function, (S25) Obtaining a dataset containing data, wherein the dataset is based on a plurality of previously executed designs, and each data contains a tuple and weights. The aforementioned tuple is, A first operator represented by a first block node in one of the multiple designs executed previously, A second operator represented by a second block node in the design, wherein the second block node has an output connector connected to the first block node, A third operator represented by a third block node having a corresponding input connector connected to the corresponding output connector of the first block node, The object type of the corresponding output connector of the first block node, The weights depend on the degree to which the tuples were instantiated in the previously executed designs, Providing input data to the machine learning function (S30), wherein the input data is at least, The data identifier of the corresponding operator represented by the block node of the selected output connector, The data identifier of the selected output connector, The object type of the selected output connector, and the following: Based on the results of the machine learning function and the dataset, output a prediction for one or more operators from a predetermined set of operators (S40), The computer system displays a graphical representation of at least one operator of the prediction (S50), The user selects an operator from among at least one operator of the prediction (S60), The aforementioned computer system, Adding a block node representing the selected operator to the 2D block representation (S70), The display of the 2D block representation is updated by at least displaying the added block nodes (S80), Add the arc between the selected output connector and the corresponding connector of the added block node to the 2D block representation, thereby obtaining the updated 2D block representation (S90), The display of the 2D block representation is updated by at least displaying the added arc (S100), The data flow represented by the arc of the updated 2D block representation is executed (S110), and the updated 3D shape representation is output thereafter. Displaying the updated 3D shape representation (S120) A design method characterized by including the following.
2. Based on the aforementioned machine learning function and the aforementioned dataset, outputting predictions for one or more operators is: As a result of the machine learning function, a first score is obtained for each given operator in a predetermined set of operators, Determining a second score for each given operator in a predetermined set of operators, wherein the second score for the given operator represents the frequency of the corresponding tuple in the dataset, The first operator of the corresponding tuple is the corresponding operator represented by the block node of the selected output connector, The second operator of the corresponding tuple is the corresponding operator represented by the preceding block node of the block node of the selected output connector, The third operator of the corresponding tuple is the given operator, The object type of the corresponding tuple is the object type of the selected output connector, The first score and the second score are combined to obtain a third score for each operator in a predetermined set of operators. The design method according to claim 1, characterized by including the following:
3. The design method according to claim 2, characterized in that the frequency of the corresponding tuple represented by the second score is the frequency of the corresponding tuple among all tuples in the dataset having the same first operator, second operator, and object type as the corresponding tuple.
4. Operator O i The second score 2 (O i ) is given by the following formula, [Math 1] [Math 2] The operator O i A set of operators that includes and is included in a predetermined set of operators, each operator O j The first operator, the second operator, and the object type are O i The third operator of the tuple is the same as that of the corresponding tuple, w j is the third operator O j The design method according to any one of claim 3, characterized in that the weight of the tuple is as follows.
5. The design method according to any one of claims 2 to 4, characterized in that the third score of each operator in a predetermined set of operators is a convex coupling of the first score and the second score of the operator.
6. the third score Score of operator O in the predetermined set of the operators 3 (O) is given by the following formula, [Math 3] c and c' are numerical coefficients, Score 1 (O) is the first score of operator O, Score 2 The design method according to claim 5, characterized in that (O) is the second score of the operator O.
7. The user selects an operator from among the at least one operators of the prediction, and then increases the weights of the corresponding tuples in the dataset by a predetermined number. The first operator of the corresponding tuple is the corresponding operator represented by the block node of the selected output connector, The second operator of the corresponding tuple is the corresponding operator represented by the preceding block node of the block node of the selected output connector, The third operator of the corresponding tuple is the selected operator, The design method according to any one of claims 1 to 6, further comprising the fact that the object type of the corresponding tuple is the object type of the selected output connector.
8. The design method according to any one of claims 1 to 7, characterized in that the input data of the machine learning function further includes values that depend on the object cardinality of the selected output connector.
9. The design method according to claim 8, characterized in that the value depending on the object cardinality of the selected output connector is a binary value indicating whether the cardinality is 1 or greater than 1.
10. The design method according to any one of claims 1 to 9, characterized in that the machine learning function is a multilayer perceptron.
11. A computer program comprising instructions, characterized in that, when executed by a processor, causes the processor to execute the design method described in any one of claims 1 to 10.
12. A computer-readable recording medium characterized by recording the computer program described in claim 11.
13. A system comprising a processor coupled to memory, wherein the memory stores the computer program described in claim 11.
