Flexible modeling using weak typing

Abstract

The present invention particularly relates to a data structure for defining a three-dimensional (3D) model. The data structure comprises a delegate data object. The delegate data object comprises input parameters specific to the type of the delegate data object, and at least one operator specific to the type of the delegate data object for generating an output topology. The data structure also comprises an output topology generated by the operator.

Description

Technical Field

[0001] The present invention generally relates to the field of computer programs and systems, and more particularly to data structures, methods, systems and programs for designing 3D models. Background Art

[0002] Many systems and programs for design, engineering and manufacturing of objects are available on the market. CAD is an abbreviation for computer-aided design, for example, it refers to software solutions for designing objects. CAE is an abbreviation for computer-aided engineering, for example, it refers to software solutions for simulating the physical behavior of future products. CAM is an abbreviation for computer-aided manufacturing, for example, it refers to software solutions for defining manufacturing processes and operations. In such computer-aided design systems, graphical user interfaces play an important role in technical efficiency. These technologies can be embedded in product lifecycle management (PLM) systems. PLM refers to a business strategy that can help companies share product data, apply common processes, and develop products from concept to end of life using corporate knowledge in the entire concept of the extended enterprise. The PLM solution provided by Dassault Systèmes (trademarks CATIA, ENOVIA and DELMIA) provides an engineering center for organizing product engineering knowledge, a manufacturing center for managing manufacturing engineering knowledge, and a business strategy that integrates and connects companies to engineering and manufacturing centers. Together, the system delivers an open object model that links products, processes, resources together to enable dynamic, knowledge-based product creation and decision support that drives optimized product definition, manufacturing preparation, production, and service.

[0003] CAD software proposes methods for creating three-dimensional (3D) models called parts using a set of tools that can be divided into two categories: history-based methods (also called parametric modeling) and history-free methods (also called explicit modeling).

[0004] The history-based approach is designed to capture design intent by storing each step of the creation process using features, constraints, etc. It is effectively like a part recipe; each step of creation exposes a set of parameters that the user can change. If one parameter does change, the entire 'recipe' is reproduced in the exact same order to regenerate the new part. The approach is often represented using a tree that allows the user to quickly understand the sequence of operations.

[0005] The history-free approach does not rely on a sequence of operations that are reproduced at each modification. Each modification is made to the current 3D model. That is, there are no intermediate steps, no "recipes", and when the user modifies his design, the modification is absorbed by the features and, therefore, the parameters that led to that modification are not preserved. Because the order of the operations performed is not preserved, this approach allows the user to create 3D models faster and more freely. The user can focus on the geometry he is creating without having to worry about the order in which he creates the features. Moreover, the user does not have to worry about the effects of the modifications.

[0006] The advantage of the history-based approach is also its disadvantage. Although parametric methods are very convenient for changing parameters at almost any time, it introduces rigidity to the design process. Once the "recipe" is created, each feature is strongly typed and you can only use these parameters. Any other changes can be very complicated because to get the changes the user wants, he must consider how it will affect the results when the part is regenerated. This is a major disadvantage in situations where the user wants to test different types of shapes and wants to iterate quickly. History-based methods are mainly used to create mechanical parts that represent real-world objects to be manufactured, while history-free methods are mainly dedicated to concept modeling or organic shapes of products in the A-stage.

[0007] The objects used in the history-based approach are strongly typed. In order to change the type of an object, a completely new object needs to be created and replaced with the new one in a tree representing the sequence of operations. The new object, which does not have any links to the replaced object, may not fit the current recipe due to the change in topology. This happens if an operation can no longer find the elements it needs to calculate its modification because the objects it depends on have changed. In this case, the user will have to explicitly tell the system what to do. This is a tedious task that becomes more tedious and time-consuming the more complex the history.

[0008] With the history-free approach, the user can quickly iterate on shapes because the feature he is working with has no type at all. The user does not need to care about the impact of the current modification on the history of the object being designed. Also, since no history is stored in the generic feature (the feature being designed), the user is working on the current state of the object. Therefore, even though the user can quickly iterate on his shapes, he can only modify the current state of his 3D shape. He cannot access any parameters of any of his previous operations.

[0009] History-based and history-free approaches are not incompatible, since objects generated from a history-free context can be integrated in a history-based context. More precisely, users can create history-free models and manipulate them to generate new 3D models from them.

[0010] However, the data structures of the two approaches are not interoperable. In fact, the data structures of objects generated by history-based and history-free approaches are somewhat different; in particular because the data structures of objects in history-based approaches are strongly typed, while those in history-free approaches are untyped (designers work with generic features (also called "datums"), which do not have any type). The type of a 3D model in the context of history-based refers to its characteristics, which are defined by a set of parameters and at least one operation that takes a set of parameters as input and returns an object topology as output. For example, and with reference to Figure 1 , a 3D sphere is a type of 3D model, the "sphere" type has its parameters set, namely its center, radius and opening angle. This brings operations that take all these parameters as input and are able to return a sphere topology. In contrast, in a history-free context, the created shapes are by definition untyped, since the object does not have any parameters. Each operation applied to an object will be applied to the current definition of that object. Figure 3 In the example above, the user will only have access to the topology of the sphere (i.e., the wireframe consisting of all vertices and edges), and based on that information can make faces.

[0011] In summary, the data structure of a history-based method includes type-specific input parameters, at least one operation specific to the type, and the output topology generated by the previous operation. The data structure of a history-free method includes the current topology generated by the last external operation applied to the object.

[0012] Due to these fundamental differences between the two approaches, current history-free approaches do not allow for capturing the "recipe" of modifications that a user has performed on a 3D model (equivalently, on a mesh). In particular, it is not possible to automatically capture and apply the same or similar design operations performed on a first 3D model on a new mesh. For example, a designer who has modified the design of a door of a first car model cannot automatically apply the same modifications to the door of a second car model. This means that it is almost impossible to reuse design intent with a history-free CAD approach; the designer must intuitively make modifications to the mesh of the second car model in the hope of reproducing his / her original design intent.

[0013] In this context, there remains a need for an improved data structure for defining 3D models for history-free methods. Summary of the invention

[0014] Therefore, a data structure defining a three-dimensional (3D) model is provided. The data structure includes a delegate data object. The delegate data object includes input parameters specific to the type of the delegate data object, and at least one operator specific to the type of the delegate data object to generate an output topology. The data structure also includes an output topology generated by the operator.

[0015] The data structure may also include an interface for adding or removing at least one operator.

[0016] In addition, a computer-implemented method for designing a three-dimensional (3D) model is provided. The method comprises: providing a first data structure, the first data structure defining a first 3D model including a first delegate data object and a first output topology; modifying the first delegate data object according to a user action; calculating a second output topology due to the modification of the first data structure; determining whether a topological change occurs by comparing the first output topology with the second output topology; if a topological change occurs between the first output topology and the second output topology, replacing the first delegate data object with the second delegate data object, or maintaining the first delegate data object if it is determined that no topological change occurs.

[0017] The method may also include one or more of the following:

[0018] - replacing the first delegation data object with the second delegation data object comprises: - comparing the second output topology with a list of output topologies, each output topology in the list being associated with a delegation data object; - as a result of the comparison, automatically selecting a third delegation data object, the third delegation data object being a delegation data object in the list having the same associated output topology as the second output topology;

[0019] - if as a result of said comparison no delegation data object of said list is selected, then: - one or more delegation data objects in said list having an associated output topology closest to said second output topology are provided to said user, wherein said one or more delegation data objects include a generic delegation data object; - one of the provided delegation data objects is selected by said user;

[0020] - modifying said first delegate data object according to a user action comprises: - modifying one or more input parameters of said first delegate data object; - determining as a result of said comparison that no topology change has occurred; - overwriting said input parameters of said first delegate data object with said modified one or more input parameters;

[0021] - after providing the first data structure: presenting the first output topology, thereby forming a grid; modifying the grid according to user actions;

[0022] - modifying the grid comprises: performing at least one operation selected from scaling and moving; wherein maintaining the first delegated data object further comprises: generating the first output topology through the operator of the first delegated data object;

[0023] - the first delegated data object and the first output topology form a base mesh;

[0024] - Replacing the first delegate data object with the second delegate data object further comprises: storing the second delegate data object as a new type.

[0025] In addition, a computer program is provided, which includes instructions for executing the above method.

[0026] In addition, a computer-readable storage medium is provided, on which the computer program and / or the data structure are recorded.

[0027] Furthermore, a system is provided, comprising a processor coupled to a memory having recorded thereon the computer program and / or the data structure. The system may also include a graphical user interface. BRIEF DESCRIPTION OF THE DRAWINGS

[0028] Embodiments of the invention will now be described by way of non-limiting examples and with reference to the accompanying drawings, in which:

[0029] - Figure 1 An example of a strongly typed object is shown;

[0030] - Figures 2 to 4 An example of the data structure of the present invention is shown;

[0031] - Figures 5 and 6 An example of the build phase is shown;

[0032] - Figure 7 A method for designing a 3D model using the data structure is shown;

[0033] - Figures 8 to 9 Shows Figure 7 Example:

[0034] - Fig.10a , 10b , 11a, 11b, 12a, 12b show the base grid of the data structure output; and

[0035] - Fig.13 An example of a system is shown;

[0036] - Figures 14a to 14d An example of a base grid defined by a data structure is shown. DETAILED DESCRIPTION

[0037] Reference Figure 4A data structure for defining a three-dimensional (3D) model is proposed. The data structure includes a delegate data object and an output topology generator. The delegate data object includes input parameters specific to the type of the delegate data object and at least one operator specific to the type of the delegate data object for generating an output topology.

[0038] This data structure improves the design of 3D models in history-free computer-aided design systems.

[0039] It is worth noting that this data structure can remove the limitations of the history-free approach by introducing the concepts of "weak typing" and "flexible modeling". Like the history-free approach, the data structure that defines the 3D model is generic. Instead of taking as input the object that defines its type, the generic object delegates its type to another object. This other type of object is also called "weakly typed". Thanks to this delegated data object, it is possible to design a 3D model by using a data structure that is a generic feature: the generic feature has a type similar to that in the history-based approach. However, the type does not have a strong link to the feature because the type has been delegated to the delegated data object. This allows the feature to change type throughout its life cycle depending on the context and operation. Therefore, the data structure is sufficiently generic that it can be maintained during the design operation and changed when necessary or when requested by the designer. In addition, the data structure provides new possibilities for designers in terms of feature creation: in fact, the delegated data object is not necessarily linked to a common feature (e.g., plane, cylinder, sphere, torus...) and any shape (e.g., designed by the user) can be used to obtain the type of a new delegated data object.

[0040] Reference Figure 7 , a method for designing a 3D model by using the data structure is proposed. The proposed method comprises: providing a first data structure according to the present invention. The first data structure defines a first 3D model including a first delegated data object and a first output topology. Subsequently, the method comprises: modifying the first delegated data object of the first data structure according to a user action. The method also comprises: calculating the second output topology due to the modification of the first data structure. The method also comprises: determining whether a topological change occurs by comparing the first output topology and the second output topology. The method also comprises: if it is determined that a topological change occurs between the first output topology and the second output topology, replacing the first delegated data object with the second delegated data object, or if it is determined that no topological change occurs, maintaining the first delegated data object.

[0041] This method improves the design of 3D models in a history-free computer-aided design system. It is noteworthy that the method uses the data structure, which allows the limitations of the history-free method to be lifted by introducing the concepts of "weak typing" and "flexible modeling". Therefore, the method allows the retention or replacement of the delegate data object depending on whether a topological change occurs when designing the first 3D model. Due to the history-free method, there is no storage of the continuous operations completed on the 3D model, and each operation is performed on the last state of the feature. This means that some operations can change the data structure or the delegate data object of the common feature. When this happens, the delegate data object will be replaced with a more suitable delegate data object. However, all operations (such as design operations) are not too destructive, and in some cases they can leave the delegate object unchanged, because in fact, the operation is modifying one of the delegate object parameters. In addition, the method ensures that the objects visible in the feature tree will never change, and only the underlying delegate data object will change. Therefore, when the delegate data object changes, the system still knows the previous type and the new type of the 3D model. Although the delegate data object is replaced with a new object, the knowledge about the replaced object can be retained. Therefore, the flexibility of the history-free method is improved.

[0042] The method is computer-implemented. This means that the steps (or substantially all steps) of the method are performed by at least one computer or any similar system. Thus, the steps of the method may be performed by a computer, which may be fully automatic or semi-automatic. For example, the triggering of at least some steps of the method may be performed by user-computer interaction. The required level of user-computer interaction may depend on the foreseen level of automation and be balanced with the need to implement the user's wishes. For example, the level may be user-defined and / or predefined.

[0043] For example, the step of modifying the first delegated data object is performed according to a user action, for example during a design operation.

[0044] A typical example of a computer implementation of a method is to perform the method using a system suitable for the purpose. The system may include a processor coupled to a memory and a graphical user interface (GUI), the memory having recorded thereon a computer program, the computer program including instructions for performing the method. The memory may also store a database. The memory is any hardware suitable for such storage, which may include several physically distinct parts (e.g., one for the program and possibly one for the database).

[0045] The data structure defines the 3D model, and the method generally manipulates the data structure and thus the 3D model. The 3D model is also referred to as a modeling object. A modeling object is any object defined by data stored in, for example, a database. By extension, the expression "modeling object" represents the data itself. Depending on the type of system, the modeling object can be defined by different kinds of data. The system can indeed be any combination of a CAD system, a CAE system, a CAM system, a PDM system and / or a PLM system. In these different systems, the modeling object is defined by corresponding data. Therefore, CAD objects, PLM objects, PDM objects, CAE objects, CAM objects, CAD data, PLM data, PDM data, CAM data, CAE data can be mentioned. However, these systems are not mutually exclusive, because the modeling object can be defined by data corresponding to any combination of these systems. It will be apparent from the definitions of these systems provided below that the system can therefore be a CAD and PLM system very well.

[0046] In CAD systems, it also means any system that is at least suitable for designing modeled objects based on a graphical representation of the modeled objects (such as CATIA). In this case, the data defining the modeled objects include data that allow the modeled objects to be represented. For example, the CAD system can use edges or lines (in some cases, using faces or surfaces) to provide a representation of the CAD modeled objects. Lines, edges or surfaces can be represented in various ways, for example using non-uniform rational B-splines (NURBS). In particular, CAD files contain specifications from which geometry can be generated, allowing the generation of representations. The specifications of the modeled objects can be stored in a single CAD file or in multiple CAD files. The typical size of the files representing the modeled objects in the CAD system is in the range of 1M bytes per component. Modeled objects can typically be a combination of thousands of components.

[0047] In the context of CAD, a modeled object may generally be a 3D modeled object, for example representing a product such as a part or a combination of parts, or may be a combination of products. A "3D modeled object" refers to any object that is modeled by data that allows its 3D representation. The 3D representation allows the part to be viewed from all angles. For example, when represented in 3D, 3D modeled objects can be manipulated and rotated about any of their axes or about any axis in the screen on which their representation is displayed. It is worth noting that this does not include 2D icons that are not modeled in 3D. The display of a 3D representation facilitates design (i.e., increases the speed at which designers complete their tasks in a statistical sense). Since the design of a product is part of the manufacturing process, the industrial manufacturing process can be accelerated.

[0048] A 3D modeled object may represent the geometry of a product to be manufactured in the real world after virtual design of a product (e.g., a (e.g., mechanical) part or combination of parts (or equivalently, an assembly of parts, since from a methodological point of view an assembly of parts may be considered as a part itself, or the method may be applied independently to each part in the assembly), or more generally any rigid body part (e.g., a mobile device)) has been completed using, for example, a CAD software solution or a CAD system. CAD software solutions allow the design of products in a wide variety of unlimited industrial fields, including: aerospace, architecture, construction, consumer goods, high-tech equipment, industrial equipment, transportation, ships and / or offshore oil and gas production or transportation. Therefore, the 3D modeled object designed by this method can represent an industrial product, which can be any mechanical part, such as a part of a land vehicle (which includes automobile and light truck equipment, racing cars, motorcycles, trucks and automobile equipment, trucks and buses, trains), a part of an air vehicle (for example, it includes fuselage equipment, aerospace equipment, propulsion equipment, defense products, aviation equipment, space equipment), a part of a naval vehicle (which includes naval equipment, commercial ships, offshore equipment, yachts and workboats, marine equipment), a general mechanical component (for example, it includes industrial manufacturing machinery, heavy mobile machinery or equipment, installed equipment, industrial equipment products, metal products, tire manufacturing products), electromechanical or electronic components (for example, it includes consumer electronics, safety and / or control and / or instrumentation products, computing and communication equipment, semiconductors, medical equipment or instruments), consumer products (for example, it includes furniture, home and garden products, leisure products, fashion products, products of hard goods retailers, products of soft goods retailers), packaging (for example, it includes food and beverages and tobacco, beauty and personal care, household product packaging).

[0049] A PLM system further refers to any system suitable for managing modeling objects representing physical manufactured products (or products to be manufactured). Thus, in a PLM system, modeling objects are defined by data suitable for manufacturing physical objects. These data can typically be dimension values ​​and / or tolerance values. Having such values ​​is indeed better for the correct manufacturing of the object.

[0050] CAM solution also means any solution, hardware or software, suitable for managing the manufacturing data of a product. Manufacturing data generally includes data about the product to be manufactured, the manufacturing process and the resources required. A CAM solution is used to plan and optimize the entire manufacturing process of a product. For example, it can provide the CAM user with information about the feasibility, the duration of a manufacturing process or the number of resources (e.g. a specific robot) that can be used at a specific step of the manufacturing process; thus allowing a decision to be made on management or the required investment. CAM is a subsequent process after the CAD process and potentially the CAE process. Such CAM solutions are manufactured by Dassault Systèmes under the trademark CAM. To provide.

[0051] CAE solution also means any solution, hardware or software suitable for analyzing the physical behavior of a modeled object. The Finite Element Method (FEM) is a well-known and widely used CAE technique that generally involves decomposing the modeled object into elements whose physical behavior can be calculated and simulated by equations. This CAE solution is manufactured by Dassault Systèmes under the trademark Another evolving CAE technology involves modeling and analyzing complex systems consisting of multiple components from different physical domains, but for which no CAD geometry data is available. CAE solutions allow simulations to be performed, thus allowing the optimization, improvement and validation of the product to be manufactured. This CAE solution is manufactured by Dassault Systèmes under the trademark To provide.

[0052] PDM stands for Product Data Management. A PDM solution means any solution, hardware or software, suitable for managing all types of data related to a specific product. All participants in the product life cycle can use a PDM solution: mainly engineers, but also project managers, finance, sales and purchasing. PDM solutions are usually based on a product-oriented database. It allows participants to share consistent data on their products, thus preventing participants from using different data. This type of PDM solution is developed by Dassault Systèmes under the trademark To provide.

[0053] Fig.13 An example of a system is shown, where the system is a client computer system (eg, a user's workstation).

[0054] The client computer of this example includes a central processing unit (CPU) 1010 connected to an internal communication bus 1000, a random access memory (RAM) 1070 also connected to the bus. The client computer is also provided with a graphics processing unit (GPU) 1110, which is associated with a video random access memory 1100 connected to the bus. The video RAM 1100 is also referred to in the art as a frame buffer. A mass storage device controller 1020 manages access to a mass storage device (e.g., a hard disk drive 1030). Mass storage devices suitable for tangibly embodying computer program instructions and data include all forms of non-volatile memory, for example, including: semiconductor memory devices, such as EPROM, EEPROM, and flash memory devices; magnetic disks, such as internal hard disks and removable disks; magneto-optical disks; and CD-ROM disks 1040. Any of the above may be supplemented by, or incorporated into, a specially designed ASIC (application specific integrated circuit). A network adapter 1050 manages access to a network 1060. The client computer may also include a tactile device 1090, such as a cursor control device, a keyboard, and the like. The cursor control device is used in the client computer to allow the user to selectively position the cursor at any desired location on the display 1080. In addition, the cursor control device also allows the user to select various commands and input control signals. The cursor control device includes a plurality of signal generating devices for inputting control signals to the system. Typically, the cursor control device may be a mouse, the buttons of which are used to generate signals. Alternatively or additionally, the client computer system may include a sensitive pad and / or a sensitive screen.

[0055] The computer program may include instructions executable by a computer, the instructions including units for causing the above-mentioned system to perform the method. The program may be recorded on any data storage medium (including the memory of the system). For example, the program may be implemented in digital electronic circuits or computer hardware, firmware, software, or a combination thereof. The program may be implemented as a device, for example, a product tangibly embodied in a machine-readable storage device to be executed by a programmable processor. The method steps may be performed by executing an instruction program by a programmable processor to perform the functions of the method by operating on input data and generating output. Therefore, 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 send data and instructions to a data storage system, at least one input device, and at least one output device. If necessary, the application may be implemented in a high-level procedural or object-oriented programming language or in an assembly or machine language. In any case, the language may be a compiled language or an interpreted language. The program may be a complete installer or updater. In any case, the application of the program on the system results in the execution of the instructions of the method.

[0056] The data structure is functional data for controlling and storing the operation of a CAD system (or the like). Thus, the data structure is used to control the operation of designing a 3D model on, for example, a history-free CAD system. In particular, the data structure improves the design operation because the types and parameters of the created shapes are passed to the generic features, which are not strongly typed but rather weakly typed. Here, the data structure is functional data for the technical features of the design 3D model (e.g., representing a real-world object).

[0057] "Designing a 3D modeled object" specifies any action or series of actions that is at least part of a process of drafting a 3D modeled object. Thus, the method may include creating a 3D modeled object from scratch. Alternatively, the method may include providing a previously created 3D modeled object and then modifying the 3D modeled object. The method may be included in a manufacturing process, which, after executing the method, may include: producing a physical product corresponding to the modeled object. In any case, the modeled object designed by the method may represent a manufactured object. Thus, the modeled object may be a modeled entity (i.e., a modeled object representing an entity). The manufactured object may be a product, such as a part or a combination of components. Because the method improves the design of the modeled object, the method also improves the manufacture of the product, thereby increasing the productivity of the manufacturing process.

[0058] Figure 1An example of a strongly typed data structure commonly used by known history-based CAD systems is shown. In this example, the data structure defines a feature 3D Sphere, where the 3D Sphere is a typed 3D model. The feature 3D Sphere defines a 3D Sphere type with a set of parameters, which are the center, radius, and splay angle of the sphere. The data structure comes with a single operation, which is a sphere operation. The output of this type of feature returns the topology of the sphere, such as Figure 1 as shown on the right.

[0059] Now, from the point of view of the history-free approach, only the mesh representing the sphere is available to the system. The paradigm of history-free is that the feature is generic: this means that the CAD system does not know that the mesh (the wireframe with all vertices, edges, and faces of the wireframe can be made from this information) represents a sphere, because the CAD system only has access to the mesh. Therefore, even if the designer can quickly iterate the shape, he can only modify the current state of the mesh; therefore, it is not possible to modify only the parameters of the sphere, for example, the designer cannot modify the radius of a mesh with the 3D shape of a 3D sphere.

[0060] Figure 2 An example of a data structure of the present invention is shown. The data structure (or feature) is generic, meaning that the data structure is untyped and therefore not linked to a specific type of object (e.g., a spherical primitive). A feature is a component from which a shape can be obtained. Features are commonly used in 3D modeling to construct 3D modeled objects. As a non-limiting example, a "typical" feature can have the following types: parallelepiped (e.g., a cuboid), cylinder, sphere, pyramid, cone, quadratic surface, ruled surface, ring, etc. In general, a feature can represent any shape, even very complex shapes, such as a car or an airplane, and the feature has a set of parameters sufficient for a specific operator to generate the shape. A set of features can allow the description of an industrial product (e.g., an industrial product represented as a mesh in a historical CAD system).

[0061] The data structure is generic and can be used in history-free CAD systems. Generic features are independent of the type of feature. However, a generic feature can receive data, execute data and obtain results similar to those provided by a feature of a certain type. The data structure takes as input a delegate data object that defines the feature type. The delegate data object facilitates "weakly typed" generic features. This means that the data structure is generic and its genericity is constrained by the delegate data object. Since the data structure is generic, the data structure is not linked to a specific operation. The operation is provided with the delegate data object. Therefore, the (generic) data structure inherits a certain type and operators specific to the type of the delegate data object. The inheritance is performed by providing a delegate data object (which includes the type and the specific operator) as input to the generic feature. The output is the topology calculated by the generic feature based on the input. Therefore, the topology is specific to the type provided in the input.

[0062] This is Figure 3 This is described in Figure 3 In , the (generic) data structure accepts as input a delegate data object of type sphere, and the topology produced by the data structure is a sphere. The production of spheres is controlled by operators of that type, which are executed (or run) by the data structure. Thus, the data structure gets the operator of the delegate data object and then executes it.

[0063] The delegate data object includes input parameters of a type specific to the delegate data object. The delegate also includes one or more operators specific to the type of the delegate data object.

[0064] Figure 4 An example of a delegate data object specific to the 'sphere' type is shown. When the delegate object is executed by a generic feature, that is, when the system asks the 'sphere' feature to build itself, the generic feature delegates it to the delegate data object for that specific type. In the above example, the delegate data object knows that the sphere should be built using 'center', 'radius' and 'opening angle' as parameters. In this way, the delegate object will use its input parameters to generate an operation. The generic feature will then use this operation to generate its topology. Therefore, if the delegate object is replaced with another object for any reason, it will be transparent from the perspective of the generic feature because it will still obtain and run the operation given by the delegate object.

[0065] The parameters of the delegate data object allow instantiation of operators that generate the output topology. For example, as known in the art:

[0066] -The input parameters specific to the "Sphere" type are center, radius and opening angle;

[0067] - Input parameters specific to the "Cylinder" type are the direction of the axis, the height of the cylinder, the center and radius of the circle;

[0068] - Input parameters specific to the "Cone" type are the axis direction, the height of the cone, the center of the cone base, and the radius;

[0069] -The input parameters specific to the Torus type are the direction vector, the center, the radius of the large circle, and the radius of the small circle.

[0070] The data structure also includes the output topology produced by the operator. The topology depends on the type of the delegate data object.

[0071] For example, an operation may be performed by an operator specific to the type of the delegate data object. In this case, the operation is also called an internal operation: it does not modify the topology of the output topology. Internal operations are typically operations that are performed as a result of modifying an input parameter of a delegate data object (e.g., a scale or shift of the output topology). A list of these operations may be associated with a delegate data object, so that the generic feature has knowledge of the modifications that the operations that have been "loaded" on the generic feature can perform.

[0072] For example, an operation can be performed by an operator that is not a specific operator of the delegated data object. In this case, the operation is also called an external operation: modifying the output topology. External operations are typically operations that cannot be performed by operators of delegated data objects when modifying the topology of the output (for example, performing a cut on a 3D representation of a 3D model defined by a data structure). In order to perform the operation, the data structure may include an interface suitable for adding or removing at least one operator. Operators can be "loaded" on the data structure and executed. Operators of delegated data objects can remain loaded on the common features or simply deleted. The data structure always contains at least one operator.

[0073] For example, the output topology can be presented so that a representation of the 3D model defined by the data structure can be accessed (e.g., displayed to a user). As is known in the art, the output topology can be represented by a mesh. The mesh can be a subdivision surface, which is a method of representing a smooth surface by specifying a coarser piecewise linear polygonal mesh. A mesh is a collection of vertices, edges, and faces that define the shape of a 3D model. Therefore, the mesh defines the geometry from which a graphical representation of the output topology of the 3D model can be generated. The mesh can be a subdivision surface, which is typically used to model free-form surfaces of arbitrary topology. The subdivision surface is defined as the limit of a refinement process starting from a polygonal base mesh of control points. The control points of the base mesh pass progressive changes to the subdivision surface. Therefore, as a result of the iteration of the subdivision process, the mesh of the subdivision surface is refined, and the subdivision process is controlled by the control points of the base mesh. Therefore, the subdivision surface will approximate or interpolate the base mesh. The Catmull-Clark algorithm is an example of such a subdivision scheme. The base mesh is widely used in CAD, and a simple definition can be: the base mesh includes the definition of the subdivision mesh and the control points of the subdivision mesh. It should be understood that some dedicated algorithms may be used.

[0074] Thus, a design operation may be a modification of a mesh when a user operates one of the control points of the base mesh. Fig.14a , 14b Examples of design operations on the base grid are shown in Figures 14c and 14d. Fig.14a An example of a base mesh that is a cubic base mesh is shown. The cubic base mesh has 8 control points and the edges are of equal length. There are no vertex, edge, or face weights attached. Fig.14b , the user has replaced (or moved) Fig.14a The control points of the base mesh of , which control the subdivision of the original cube into spheres using, for example, the Catmull-Clark algorithm. Fig.14c Shown is a cubic base mesh (8 control points) Fig.14a The base mesh of the obtained subdivision surface has the same length of the edges and the two opposite faces have weights (100% sharpness). Thus, a cylinder is obtained. Fig.14d Shown is a cubic base mesh (8 control points) Fig.14a The subdivision surface is obtained from the base mesh of the same length of edges with weights on each edge (100% sharpness). A cube is obtained. In these examples, the control points modify the weights of the vertices or edges or faces, thus modifying the subdivision process. The weights form the attractiveness of the mesh.

[0075] Reference now Figure 5 and Figure 6, we now discuss the construction phase of the 3D model defined by the data structure according to the present invention.

[0076] Figure 5 Represents the construction phase of a common feature in history-free systems known in the art. When the user requests a modification of a shape, the system goes through the construction phase of that shape. Typically, during this phase, an operator representing the current modification is called, the result of which is a new shape associated with the current shape. The construction phase has one output, the new shape.

[0077] Figure 6 The construction phase of the data structure of the present invention is different because it not only calculates the new shape according to the current modification, but also ensures that the delegate data object is still consistent, and if not, provides a new delegate data object to the data structure.

[0078] Reference now Figure 7 Let's talk more precisely about the construction phase. Figure 7 is an example of a computer-implemented method for designing a 3D model using the data structure of the present invention.

[0079] At S10, a first data structure according to the present invention is provided. The first data structure defines a first 3D model and includes a first delegate data object and a first output topology. The first output topology defines a current geometry, which may be a current representation of the 3D model (eg, displaying a base mesh).

[0080] At S20 , a construction phase is performed.

[0081] The construction phase starts with a user modification (S21) of a first delegate data object. The modification of the first delegate data object may comprise directly modifying one or more input parameters of the first delegate data object. Alternatively, the modification may comprise modifying the 3D model (3D shape, i.e. a representation of the 3D model) without explicitly modifying one or more parameters of the delegate data object. Another possibility is to replace the first delegate data object with another delegate data object.

[0082] Then, it is determined (S22) whether a change in the first output topology (S21) has occurred due to the user modification. It should be understood that the detection of the occurrence of a topology change may be performed using any known technique.

[0083] In one example, the determination is performed by performing a comparison between the first output topology and a second output topology, wherein the second output topology is the topology obtained after user modification.

[0084] The comparison between the first output topology and the second output topology may include performing a comparison between a first base mesh and a second base mesh, wherein the first base mesh is a base mesh corresponding to the geometry before modification and the second base mesh is a base mesh corresponding to the modified geometry. It is easier to calculate the topology change from the mesh.

[0085] If the current operation (S21) retains the adopted (delate) data object (ie, the type 3D shape is not changed due to the modification), then S23 is executed. Otherwise, S24 and S25 are executed.

[0086] Now refer to Figure 8 Let's discuss S23. Since it is determined that no topological change has occurred, the first delegate data object will be retained. In other words, the type of the 3D model has not changed. In the case where one or more parameters of the first delegate data object have been modified, or the modification of the 3D shape does not affect the first topological output without explicitly changing the weakly typed parameters.

[0087] Therefore, when the user modifies one or more input parameters of the first delegate data object, the modified one or more input parameters are used to overwrite the input parameters of the first delegate data. Interestingly, in this case, verification of the topology change may not be performed.

[0088] Furthermore, when modifying the 3D shape without explicitly changing the weakly typed parameters does not affect the first topological output, the first delegate data is retained and the parameters are modified according to the modification of the 3D shape. New values ​​of one or more parameters are calculated according to the modification of the 3D shape. The calculation of the one or more new values ​​is performed as known in the art.

[0089] The user can modify the 3D shape by modifying the mesh directly. In this case, as known in the art, a first output topology is presented to form a base mesh. The user modifies the base mesh, for example, the user moves vertices or edges or control points of the base mesh.

[0090] For example, the modification of the (base) mesh comprises performing at least one operation selected from scaling, moving, ... Since these operations are known to be topologically neutral (that is, they do not modify the topology), the first output topology will be generated by the unchanged operators of the first delegate data object.

[0091] Reference now Fig. 9 Let's discuss S24 and S25. At S24, a new delegate data object is selected to replace (S25) the current delegate data object which is no longer valid.

[0092] The identification of the new delegate data object may be performed by comparing the second output topology (the new topology obtained as a result of the modification) with the output topologies of the list of output topologies. Each output topology of the list is associated with a delegate data object, so that when a correspondence between the new output topology and the output topology of the list is identified, the associated delegate data object is retained as new. Otherwise, a third delegate data object is selected as a result of the comparison, and the third delegate data object is a delegate data object in the list that has the same associated output topology as the second output topology. The selection of the third delegate data object may be performed automatically (e.g., without user intervention).

[0093] Alternatively, the comparison may be performed between 3D shapes; in this case, the list comprises the 3D shapes associated with the delegate data objects.

[0094] However, there may be situations where a new delegate data object cannot be selected in the list. A typical reason may be that the same topology is not referenced in the list. In this case, one or more delegate data objects in the list with an associated output topology closest to the second output topology are provided to the user. As is known in the art, the distance between the two topologies is measured. For example, this can be performed by calculating the confusion of the mesh representing the output topology. At least the positions of the mesh vertices are compared (with a given tolerance) and finally the edges connecting the vertices are compared. Ranking can be performed using these measurements, and the ranked first topology is provided to the user.

[0095] Alternatively, a comparison may be performed between 3D shapes; in this case, a similarity measure will be performed between the current 3D shape (the shape modified according to the user operation) and the list of 3D shapes associated with the delegate data object. The delegate data object having the 3D shape most similar to the current 3D shape is presented to the user.

[0096] The list may also include a general delegation data object. If the user is not satisfied with the suggested topology, the general delegation data object may be used. Alternatively, the general delegation data object may be the only delegation data object proposed to the user.

[0097] After selecting one of the provided delegate data objects, the first delegate data object is replaced with the selected delegate data object.

[0098] Interestingly, the user may create a new type at any stage of the method, in particular when executing S24 and S25. For example, replacing the first delegate data object with the second delegate data object may include storing the second delegate data object as a new type.

[0099] Return to reference Figure 7, at S30 , after the user modification, the data structure includes the same or new weak type and topology output.

[0100] Fig.10a The data structure corresponding to the sphere type is shown. Fig.10b shows the same data structure after scaling. In fact, scaling does not modify Fig.10a The operation of the delegate data object.

[0101] Fig.11a Shows Fig.10a data structure. Fig.11b The same data structure after the extrusion operation is shown. The base mesh has been modified, thus producing a topological change in the topological output. Therefore, a subdivision is obtained, and a new delegate data object is identified in the list of delegate data objects. This delegate data object will replace the current delegate data object.

[0102] Fig.12a A generic object is shown. Figure 12b The same object is shown after a fill operation has been performed on top of the generic object. This fill operation will generate a sphere. In practice, the system is able to extract relevant information to fill in the parameter values ​​of the sphere. This is achieved by comparing the 3D shape with a list of shapes of delegate data objects. If the system identifies multiple possible delegate data objects, the user will be prompted with a message for him to choose between the possible options.

Claims

1. A method for providing a data structure defining a three-dimensional (3D) model, comprising: Providing a delegation data object, wherein providing a delegation data object comprises: providing input parameters specific to the type of the delegate data object; and providing at least one operator specific to said type of said delegated data object for generating an output topology; and provides the output topology generated by the operator, wherein the data structure is functional data for controlling and storing operations for designing the three-dimensional model on the history-free CAD system, and Wherein, the data structure is not linked to any geometric type or operation, and when the delegate data object is taken as input by the data structure, the data structure inherits the type and the operator of the delegate data object.

2. The method according to claim 1, further comprising: Provides an interface for adding or removing at least one operator.

3. A computer-implemented method for designing a three-dimensional (3D) model on a history-free CAD system, comprising: - providing a data structure defining a three-dimensional (3D) model, the data structure being functional data for controlling and storing operations for designing the three-dimensional model on the history-free CAD system, the data structure being configured to take as input a commissioned data object, the commissioned data object comprising: - input parameters specific to the type of the delegate data object; and - at least one operator specific to said type of said delegated data object for generating an output topology, The data structure is configured to compute an output topology generated by the operator, the data structure defining a first 3D model including a first delegate data object and a first output topology; - modifying the first delegated data object according to a user action; - calculating a second output topology as a result of said modification of said data structure; - determining whether a topology change occurs by comparing the first output topology with the second output topology; - replacing the first delegate data object with a second delegate data object if a topology change is determined to have occurred between the first output topology and the second output topology, or maintaining the first delegate data object if no topology change is determined to have occurred.

4. The computer-implemented method of claim 3, wherein: Replacing the first delegate data object with the second delegate data object comprises: - comparing the second output topology with a list of output topologies, each output topology in the list being associated with a delegation data object; - as a result of said comparison, automatically selecting a third delegated data object, said third delegated data object being a delegated data object in said list having an associated output topology that is the same as said second output topology.

5. The computer-implemented method of claim 4, further comprising: If, as a result of said comparison, no delegate data object of said list is selected, then: - providing to said user one or more delegated data objects in said list having an associated output topology closest to said second output topology, wherein said one or more delegated data objects comprise a generic delegated data object; - Selection by the user of one of the provided delegated data objects.

6. The computer-implemented method according to one of claims 3 to 5, wherein: Modifying the first delegated data object according to the user action comprises: - modifying one or more input parameters of said first delegated data object; - as a result of said comparison, determining that no topology change has occurred; and - overwriting said input parameters of said first delegate data object with the modified one or more input parameters.

7. The computer-implemented method of one of claims 3 to 5, further comprising: After providing said data structure: - presenting said first output topology so as to form a mesh; - Modifying the grid based on user actions.

8. The computer-implemented method of claim 7, wherein: Modifying the grid includes: - performing at least one operation selected from zooming, moving; and Wherein, maintaining the first delegated data object further comprises: generating the first output topology through the operator of the first delegated data object.

9. The computer-implemented method according to one of claims 3 to 5, wherein: The first delegated data object and the first output topology form a base mesh.

10. The computer-implemented method according to one of claims 3 to 5, wherein: Replacing the first delegate data object with the second delegate data object further comprises storing the second delegate data object as a new type.

11. A computer program product comprising instructions for executing the method according to any one of claims 3-10.

12. A computer-readable storage medium having recorded thereon the computer program product according to claim 11.

13. A computing system comprising a processor coupled to a memory having recorded thereon the computer program product of claim 11.

Images