Cell shrink wrap

Abstract

To provide a computer-implemented method for designing an envelope of a modeled object, and to provide a computer program, a computer-readable storage medium, and a system with a processor.SOLUTION: A method of designing an envelope of a modeled object is provided, the method comprising providing a modeled object that is discretized into a grid of cells, and computing an envelope of the provided modeled object. This achieves an improved solution regarding designing of an envelope of a modeled object.SELECTED DRAWING: Figure 1

Description

Technical Field

[0001] The present invention relates to the field of computer programs and systems, and more particularly, to a method, a system, and a program for designing an envelope of a modeled object.

Background Art

[0002] The market offers numerous systems and programs for the design, engineering, and manufacturing of objects. CAD stands for Computer-Aided Design, and refers to software solutions for designing objects, for example. CAE stands for Computer-Aided Engineering, and refers to software solutions for simulating the physical behavior of future products, for example. CAM stands for Computer-Aided Manufacturing, and refers to software solutions for defining manufacturing processes and operations, for example. In such computer-aided design systems, graphical user interfaces play a crucial role in terms of technical efficiency. These technologies can be integrated into Product Lifecycle Management (PLM) systems. PLM is a business strategy that helps companies share product data, apply common processing, and leverage enterprise knowledge to help develop products from concept to lifecycle, across the concept of an extended enterprise. Dassault Systèmes' PLM solutions (under the trademarks CATIA, ENOVIA, and DELMIA) 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 connects the enterprise to the Engineering and Manufacturing Hubs. Together, these systems provide an open object model that links products, processes, and resources to enable dynamic, knowledge-based product creation and decision support, facilitating product definition, manufacturing readiness, production, and service optimization.

[0003] Against this backdrop, the field of computer graphics offers increasingly useful technologies. Models of real-world objects are represented by complex geometry. Some design processes in the industry require envelopes, which are models that surround the original model, simplifying the details of the geometric features of the modeled object while respecting the design intent of the modeled object—that is, the designer's specifications regarding the use and purpose of the object in the real world. Thus, the design intent of the modeled object identifies the main geometric and topological features of the modeled object. The main geometric features may consist of convex and non-convex regions, and / or holes or gaps present in the model. During the design process, it may be necessary to discard invisible geometry or simplify the modeled object. Such models may contain complex geometry consisting of millions of elements that are not visible to the user (i.e., not relevant to the design intent) but are still rendered. Very complex models can become increasingly difficult to render; for example, a 3D model may contain hundreds of millions of triangles, including geometry that is not visible to the user or other internal geometry that is unnecessary for the design process. Therefore, rendering requires a computational load that has ergonomic implications for the user within the design process, such as a frame rate that is too low to enable real-time interaction. In such cases, invisible geometry can be manually removed, leaving only the external geometry. However, manually removing invisible geometry is a costly and time-consuming procedure for complex models. Furthermore, the external geometry may contain details that are unnecessary for the current design task, or it may be too complex to render in real time.

[0004] Envelopes can reduce the complexity of a geometric appearance by removing unnecessary geometry while preserving the main topological features and maintaining the design intent. This is the case, for example, in computer simulations involving augmented reality. Even if invisible geometry is not rendered, a model may be too complex to be rendered by commercial machines. In such contexts, the imposter geometry is a mesh with fewer triangles representing the actual model. Using this imposter geometry (also called a replacement model), the appearance of the original model is "baked" (a term known in the field of computer graphics) into the imposter texture. As another example, when simulating an object in a fluid, it may be necessary to simulate the fluid dynamics of only the main topological features. The model's envelope preserves the main topology but closes small gaps or holes in the part that would affect the intent of the simulation.

[0005] Several techniques exist for obtaining envelopes, and they can be used in some of the applications mentioned above. In the context of 3D graphics, wrapping is used to remove invisible faces of a 3D model and reduce the number of triangles. The wrapping described above may also be used by jacketing.

[0006] The following approach describes jacketing techniques, specifically how to determine the visibility of a model's surfaces.

[0007] The first approach is to render the model from various camera views: in this approach, the 3D model exists in 3D space, and multiple cameras are placed around the model. For each camera, an image representing the 3D model as seen from that camera is rendered. Each face that creates pixels in that image remains a visible face, but faces that did not create pixels from any camera are removed.

[0008] However, the initial approach has several drawbacks. The first drawback is that the detail of the wrap is limited by the image resolution: the less detail in the image, the less detail there will be in the wrap. The second drawback is that the detail of the wrap depends on the number of cameras. However, even if the camera density is increased and each image captured by each camera is resolved, the result is that the computation time becomes extremely long for complex models. The third drawback is that there is no guarantee that the design intent will be maintained. In fact, non-convex regions may not be properly covered, or faces may be removed even if they are visible from another (closer) view.

[0009] The second approach involves emitting "visibility rays" from a surrounding sphere. This approach extends the way the model is rendered from various camera views. The light source is placed on the sphere (surrounding the model) and emits rays toward the model. Faces hit by the rays remain visible, while faces not hit by the rays are removed.

[0010] However, this approach also has its drawbacks.

[0011] Similar to the first approach, the detail of the wrap depends on the density of the rays. However, even with a high density of rays, this results in considerable processing time for large-scale designs. A second drawback is that the design intent may not be preserved because non-convex areas are not properly covered, and surfaces may be removed even though they are visible from another (closer) view.

[0012] Shrinkwrap is an approach that shrinks and deforms a bounding sphere surrounding a model. The geometry of the deformed sphere approaches the model, meaning the deformed sphere does not intersect the original model but keeps the distance to the object short. Wraps typically cover small holes due to the "stiffness" of the wrap, but can also cover larger openings. Next, a light source is placed on the mesh of the wrap and radiates toward the mesh of the 3D model.

[0013] Let's discuss some of the drawbacks of this third approach. First, deforming the surrounding sphere requires adaptive fine-tuning of the wrap mesh and cross-testing with the original geometry. As a result, large-scale designs require considerable processing time. Second, this approach does not preserve the design intent. This is especially true if the design intent includes topological features such as holes that are not respected by the deformed sphere. For example, as is well known from the field of topology, this method cannot obtain a wrap for a donut (which has a continuous surface and a hole). In fact, the donut wrap would touch the wrap itself in the area of ​​the hole. Since the initial sphere is only adaptively fine-tuned and not cut open, it is impossible to obtain an equivalent wrap shape for objects with multiple holes. As is well known from the field of topology, the same problem applies to all geometric objects that are continuously scaled and deformed. In particular, in the case of imposter geometry, the imposter's texture content is undefined in improperly covered areas, so the imposter's geometry will behave strangely at rendering time.

[0014] Furthermore, since surfaces can be removed even when visible from a different (closer) view, the design intent may not be preserved.

[0015] We will describe an approach known as the local convex hull envelope. In this approach, the model is divided into a grid of cells containing subvolumes, also called voxels in a 3D setting. For each subvolume, the geometry of the convex hull is calculated. Finally, all hull geometries are combined to obtain the continuum surface of the complete model.

[0016] This fourth approach has several drawbacks. The size of the grid's subvolumes determines the size of the gaps that must be closed, thereby influencing the design intent. If the subvolume size is significantly smaller than the model gaps (for example, more than twice as small), the envelope enters the internal geometry through the gaps containing the internal (i.e., invisible) geometry of the modeled object, thereby capturing unwanted details. If it is too large, all gaps smaller than the subvolume may be ignored, and some geometric areas (such as non-convex areas) will not be properly covered, resulting in the envelope losing a lot of detail or failing to correctly capture some geometric areas or topological features, thus failing to maintain the design intent. Therefore, with this setup, the user must specify the subvolume size in advance. Furthermore, the constraints may be too strict to implement and / or it may be impossible to make appropriate choices to maintain the design intent, meaning that faces may be deleted even if they are visible from different views, or faces may not be deleted even if they are not visible.

[0017] Using techniques similar to the approach described above, there are existing modeling software packages for generating wraps, such as: Autodesk's Maya uses a similar method to the shrinkwrap method. In particular, it requires manual intervention to retopologize the mesh so that larger gaps and holes can be closed. Blender also uses a version of the shrink wrap method, but it's possible to shrink it to the surface of the modeled object using yet another object. However, similar to the shrink wrap method, the shrunk object does not respect the topology of the model. Therefore, the user needs to manually check if the wrap around the hole is correct. Houdini creates a convex hull for the points of the model. The drawbacks of the local convex hull method still remain; for example, the size of the hole to be closed is determined by the size of the subvolume.

[0018] Against these and other backdrops, there is still a need for improved methods for designing the envelopes of modeled objects. [Overview of the Initiative]

[0019] Therefore, a computer implementation method for designing the envelope of a modeled object is provided. This method includes: The steps include: providing a modeling object to be discretized into a grid of cells, thereby obtaining a grid containing a first set of cells intersecting the modeling object and a second set of empty cells; • Adding N adjacent layers to the modeled object, where n is a positive integer: ··For each layer, - The steps of identifying an empty cell in a second set adjacent to an intersecting cell in the first set, and - The step of adding N-1 layers by performing the step of adding the identified second set of cells to the first set of cells, ...The Nth layer, - Identify the intersecting cells in the first set and the adjacent empty cells in the second set; - The step of adding the empty cells from the identified second set to the third set of cells, and then adding them, This involves the step of adding N layers adjacent to the modeled object, The steps include calculating one or more consecutive sets of cells in the third set, The steps include: identifying one or more contiguous sets surrounding the discretized modeled object, and retaining only the cells of the identified one or more contiguous sets in a third set; For each N-1 layer added, The steps of identifying the cells of the first set and the adjacent cells of the third set, ·Step of adding the cells of the first set having the identified third set of cells as adjacent cells to the cells of the third set Execute to reduce the first set of cells (S50), and ·Step of calculating an envelope of the provided modeled object from the cells of the third set (S60).

[0020] The method may further include one or more of the following - The step of identifying one or more continuous sets surrounding the discretized modeled object further includes the following ·Step of determining whether one or more determined continuous sets are surrounded by other determined one or more continuous sets ·If one or more determined continuous sets are surrounded by other determined one or more continuous sets, the step of deleting the cells of the surrounded continuous set of the cells of the third set by adding the cells of the determined continuous set of cells to the fourth set of cells - Reducing the first set of cells further includes the following for each of the added N - 1 layers ·Step of identifying the cells of the fourth set adjacent to the cells of the first set ·Step of adding the cells of the first set having the identified cells of the fourth set as adjacent cells to the cells of the fourth set ·For each cell of the first set that does not have the identified cells of the fourth set or the identified cells of the third set as adjacent cells ··Step of determining the cells surrounding the cell, thereby forming a peripheral region of the cell ··If any cell in the peripheral region of the cell intersects with the cells of the third set or the second set, the step of adding the cell to the third set of cells, or ··If none of the cells in the peripheral region of the cell intersects with the cells of the third set or the second set, the step of adding the cell to the fourth set of cells -Determining the cells surrounding the cell includes the following ·Tracing a plurality of light rays from a first set of cells; ·Identifying the cells of the added N - 1 layers where the light rays intersect; ·Forming a peripheral region of the cell by the cells where the identified light rays intersect; -The light rays are traced with a length that decreases each time the first set of cells is reduced, where the initial length of the light ray is the length of N cells; -Before calculating the envelope, ·Identifying a third set of cells having only cells belonging to the second or third set of cells as neighboring cells, and ·Adding the identified cells to the second set of cells, Performing thinning of the third set of cells surrounding the discretized modeled object; -Before calculating the envelope, ·One or more consecutive sets of cells of the third set surrounding the discretized modeled object, ··Identifying the cells of the fourth set adjacent to the cells of the third set, and ··Adding the identified cells of the fourth set to the third set of cells, To penetrate; -Calculating the envelope of the provided modeled object from the third set of cells further includes the following ·Identifying the cells of the third set having cells of the second set of cells as neighboring cells; ·Calculating the envelope of the provided modeled object from the identified cells of the third set; - The provided modeled object is 2D geometry, the cell grid is a 2D grid, and adjacent cells are adjacent in terms of coordinates in either the x or y direction, or the provided modeled object is 3D geometry, the cell grid is a voxel grid, and adjacent cells are adjacent in terms of coordinates in either the x, y, or z direction; - The step of calculating the envelope of the provided modeled object from the identified third set of cells further includes: If the provided modeling object is 2D geometry represented by a 2D vector image and the cell grid is a 2D grid, the step of calculating the envelope by converting the cells into a set of 2D lines, or If the provided modeling object is a 3D geometry consisting of a mesh and the cell grid is a voxel grid, the step of calculating the envelope is to convert the identified cells into a quadrilateral mesh. - If the provided modeling object is 3D geometry, the envelope of the provided modeling object is calculated by converting the faces of each cell in the second set of cells and the adjacent third set of cells into a quadrilateral mesh.

[0021] Furthermore, a data structure is provided for storing the cell grid, the data structure divides the cell grid into subgrids of equal size, and each subgrid contains a pointer to at least one of the first, second, third, and fourth sets of cells in this method.

[0022] Furthermore, a computer program is provided that includes instructions for performing the method.

[0023] Furthermore, a computer-readable storage medium on which the computer program is recorded is provided.

[0024] Furthermore, a system is provided that includes a memory containing the computer program and a processor coupled to a graphical user interface. [Brief explanation of the drawing]

[0025] [Figure 1] A flowchart illustrating one example of this method is shown. [Figure 2] This shows an example of a system's graphical user interface where an envelope may be displayed. [Figure 3] This shows an example of the system. [Figure 4] This is a flowchart illustrating one example of this method. [Figure 5] This is a flowchart illustrating one example of this method. [Figure 6] This is a flowchart illustrating one example of this method. [Figure 7] This is a flowchart illustrating one example of this method. [Figure 8] This is a flowchart illustrating one example of this method. [Figure 9] This shows an example of determining the envelope for a 2D modeled object. [Figure 10] This shows an example of determining the envelope for a 2D modeled object. [Figure 11] This shows an example of determining the envelope for a 2D modeled object. [Figure 12] This shows an example of determining the envelope for a 2D modeled object. [Figure 13] This shows an example of determining the envelope for a 2D modeled object. [Figure 14] This shows an example of determining the envelope for a 2D modeled object. [Figure 15] Here is another example of determining the envelope for a 2D modeled object. [Figure 16]Here is another example of determining the envelope for a 2D modeled object. [Figure 17] Here is another example of determining the envelope for a 2D modeled object. [Figure 18] Here is another example of determining the envelope for a 2D modeled object. [Figure 19] Here is another example of determining the envelope for a 2D modeled object. [Figure 20] Here is another example of determining the envelope for a 2D modeled object. [Figure 21] Here is another example of determining the envelope for a 2D modeled object. [Figure 22] Here is another example of determining the envelope for a 2D modeled object. [Figure 23] Here is another example of determining the envelope for a 2D modeled object. [Figure 24] Here is another example of determining the envelope for a 2D modeled object. [Figure 25] Here is another example of determining the envelope for a 2D modeled object. [Figure 26] Here is another example of determining the envelope for a 2D modeled object. [Figure 27] Here is another example of determining the envelope for a 2D modeled object. [Figure 28] Here is another example of determining the envelope for a 2D modeled object. [Figure 29] Here is another example of determining the envelope for a 2D modeled object. [Figure 30] Here is another example of determining the envelope for a 2D modeled object. [Figure 31] Here is another example of determining the envelope for a 2D modeled object. [Figure 32] Here is another example of determining the envelope for a 2D modeled object. [Figure 33] This shows an example of a determined envelope for a 3D model object representing a vehicle. [Figure 34] This shows an example of a determined envelope for a 3D model object representing a vehicle. [Figure 35] This shows an example of a determined envelope for a 3D model object representing a vehicle. [Figure 36] This shows an example of a determined envelope for a 3D model object representing a bicycle. [Figure 37] This shows an example of a determined envelope for a 3D model object representing a bicycle. [Figure 38] This shows an example of a determined envelope for a 3D model object representing a bicycle. [Modes for carrying out the invention]

[0026] Referring to Figure 1, a computer implementation method for designing the envelope of a modeled object is provided. The method includes step S10, which provides the modeled object. The modeled object is discretized into a grid of cells, thereby obtaining a grid containing a first set of cells intersecting the modeled object and a second set of empty cells. The method further includes step S20, which adds N adjacent layers to the modeled object discretized into a grid of cells. N is a positive integer and represents the number of layers to be added. Since the layers are added sequentially, there exists a p value, which is an ordered positive integer less than N, indicating that corresponding layers have been added until the number N is reached. For example, if only one layer is added (N=1), the value of p will be at least p=1. If p=1, the first layer is added; if p=2, the second layer is added; if p=3, the third layer is added, and so on, until the Nth layer is added when p=N. The step of adding N layers includes, for each N-1 layers being added, identifying the empty cells in the second set that intersect with the first set of cells and are adjacent to them, and adding the identified cells from the second set to the set of cells in the first set. The step of adding N layers further includes, for the Nth layer, identifying the empty cells in the second set that intersect with the first set of cells and are adjacent to them, and adding the identified empty cells from the second set to a third set of cells. The cells in the third set are a new category of cells that define the cells of the cell grid used for the envelope calculation.

[0027] The method further includes step S30 of calculating one or more consecutive sets of cells from a third set. Thus, the method calculates sets of cells from a third set that are adjacent (i.e., adjacent to one another) within a grid of cells. For example, a line or curve may be traced within the grid across one of the consecutive sets, intersecting all the cells in the set without having any cells belonging to another set in between. Thus, this step ensures that any candidate envelope calculated from the third set of cells results in a connected, closed shape.

[0028] The method further includes step S40 of identifying one or more contiguous sets surrounding the discretized modeling object and retaining only the cells of the identified one or more contiguous sets in a third set. For example, the bounding volume may be traced within a grid that intersects with the retained cells of the third set, thereby constructing a candidate envelope.

[0029] The method further includes step S50 of reducing a first set of cells. The reduction step includes, for each N-1 added layer, identifying the cells of the first set and the cells of a third set adjacent to them, and adding the cells of the first set that have the identified cells of the third set as adjacent cells to the cells of the third set. Thus, the method extends the contiguous set surrounding the discretized modeling object to the added layers, resulting in candidate envelopes.

[0030] The method further includes step S60, which calculates the envelope of the provided modeling object from a third set of cells.

[0031] This method provides an improved solution for designing the envelope of a modeled object. The envelope is designed based on the modeled object discretized into a grid of cells, so that two categories of cells are obtained: a first set of cells that intersect with the modeled object and a second set of empty cells. The two categories of cells of the modeled object make it possible to identify the spatial distribution of the parts that make up the material of the modeled object. Thus, the provided modeled object is simplified, and the subsequent operations of the method can be performed on the two sets of cells. Such operations may be suitable for highly parallel implementations that utilize pointers indicating the two categories, enabling efficient implementations that improve computation speed. Thus, the time required to compute the envelope can be significantly reduced, further improving ergonomics for the end user.

[0032] Furthermore, this method determines a cell-based envelope for an input model with a simplified geometry, which is preferable for interactive design processes, for example, while maintaining the design intent. The design intent is maintained because the model closes small gaps, and the envelope is calculated from candidate envelopes of cells surrounding the modeled object whose gaps are closed. Gaps are closed by adding layers that extend the distribution of the modeled object represented by the cells of the first set of the grid. This corresponds to a heating process of the material of the modeled object. Gaps of modeled objects smaller than the size of the N layers added to the grid are covered. In other words, material is added to the gaps of the modeled object through N layers, independently and automatically, regardless of the size of the cell grid. The last layer added by this method (the Nth layer) is a layer containing cells that form one or more consecutive sets of cells from a third set, and thus defines one or more candidate envelopes from consecutive sets of cells from the third set. Identifying one or more consecutive sets makes it possible to identify candidate envelopes for the modeled object. Next, since the material extends in all directions of the modeled object, the added material is removed by a reduction step, which is carried out by identifying that the adjacent cells of the cells consisting of the added material are cells of the candidate envelope. In this case, the cells of the added material are added to a third set of cells, thereby extending the candidate envelope to the extent that the added material previously occupied. This corresponds to the cooling of the modeled object, which is carried out through the reduction of the first set of cells. Thus, the calculated envelope represents the main geometric features of the modeled object, maintaining the design intent and simplified by the removal of gaps.

[0033] This method is performed on a computer. That is, the steps of the method (or substantially all steps) are performed by at least one computer or any system. Thus, the steps of the method are performed by a computer, possibly fully automatically or semi-automatically. In the example, at least some steps of the method may be initiated through user-computer interaction. The required level of user-computer interaction may depend on the expected level of automation and be balanced with the need to implement the user's wishes. In the example, this level may be user-defined and / or predefined.

[0034] A typical example of a computer implementation method is to perform the method on a system suited to this purpose. The system includes a memory-coupled processor and may also include a graphical user interface (GUI), where memory stores computer programs containing instructions for performing the method. Memory may also store a database. Memory is hardware suited to such storage and may include several physically distinct parts (e.g., one for programs, one for the database).

[0035] Modeled objects can typically be 3D or 2D, representing a product, such as a part or assembly of parts, or an assembly of a product. A "3D modeled object" means an object modeled with data that enables a 3D representation. A 3D representation allows a part to be viewed from all angles in three-dimensional space. For example, a 3D modeled object, when represented in 3D, may be processed and rotated based on one of its axes or any axis of the displayed screen. A 3D modeled object may be discretized into cells via voxels defined on a voxel grid. A voxel is a volumetric element that can be identified by three-dimensional coordinates (e.g., xyz coordinates) corresponding to the voxel's position in the voxel grid. Voxels may contain further information about the 3D modeled object, such as texture or annotation / configuration information. A "2D modeled object" means a 2D representation of an object in two-dimensional space. Such a 2D representation may be defined by 2D geometry. Such 2D geometry may be represented by a matrix data structure that generally represents pixels, i.e., rectangular grids of colored points. The 2D geometry may also be represented in terms of a vector image, which is defined as a vector in Cartesian space, that is, by connecting the points of the modeled object with lines and curves to form the shape of the modeled object.

[0036] Each modeling object representing a product can have a topological structure that defines the distribution of corresponding modeling objects in geometric space. The topological structure of a model is characterized by the number of gaps, holes, and / or cavities in the model.

[0037] A modeled object is any object defined by data, for example, in a database. Therefore, the expression "modeled object" refers to the data itself. Depending on the type of system, modeled objects may be defined by various types of data. The system may actually be any combination of CAD systems, CAE systems, CAM systems, PDM systems, and / or PLM systems. In these various systems, modeled objects are defined by corresponding data. Thus, CAD objects, PLM objects, PDM objects, CAE objects, CAM objects, CAD data, PLM data, PDM data, CAM data, and CAE data may be discussed. However, since modeled objects can be defined by data corresponding to any combination of these systems, these systems are not exclusive to each other. Therefore, the system may be both a CAD and a PLM system, as will be evident from the definition of such a system described below.

[0038] The term CAD system further refers to a system, such as CATIA, that is adapted to design modeled objects based on their graphical representation. In this case, the data defining the modeled object includes data that enables the representation of the modeled object. A CAD system may provide a representation of a CAD modeled object, for example, using edges or lines, and in certain cases faces or surfaces. Lines, edges, or surfaces may be represented in various ways, with non-uniform rational B-splines (NURBS) being an example. Specifically, a CAD file may contain specifications from which geometry may be generated, thereby enabling the generation of the representation. The specifications of a modeled object may 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 may typically be an assembly of thousands of parts.

[0039] Any modeled object described herein, including the envelope obtained by this method, may represent the geometry (3D or 2D) of a product manufactured in the real world, such as a (mechanical) part or assembly of parts (an assembly of parts may be considered a part itself from the perspective of this method, or equivalent to an assembly of parts, since this method can be applied independently to each part of the assembly), or more generally, an assembly of any rigid body (e.g., a movable mechanism). Therefore, any of the aforementioned modeled objects may represent an industrial product that can be any machine part, for example, parts for land vehicles (including automobiles and light truck equipment, racing cars, motorcycles, trucks and motor equipment, trucks and buses, trains, etc.), parts for aircraft vehicles (including, for example, airframe equipment, aerospace equipment, propulsion equipment, defense products, aircraft equipment, space equipment, etc.), parts for marine vehicles (including, for example, naval equipment, commercial ships, offshore equipment, yachts and workboats, marine equipment, etc.), general machine parts (including, for example, industrial manufacturing machinery, heavy machinery or equipment, installation equipment, industrial equipment products, metalwork products, tire manufacturing products, etc.), electrical machinery or electronic components (including, for example, home appliances, security and / or control and / or measurement products, computing and communication equipment, semiconductors, medical devices and equipment, etc.), consumer goods (including, for example, furniture, home and garden products, leisure goods, fashion products, products of durable goods retailers, products of textile retailers, etc.), and packaging (including, for example, food and beverages and tobacco, beauty and personal care, household goods packaging, etc.). Any of the aforementioned modeled objects may then be incorporated into the design process via a CAD system or software solution. CAD software solutions enable the design of products in a vast array of industrial sectors, including aerospace, architecture, construction, consumer goods, high-tech equipment, industrial equipment, transportation, marine, and / or offshore oil / gas production or transportation.

[0040] Figure 2 shows an example of a CAD system GUI.

[0041] GUI2100 may have a typical CAD-like interface with standard menu bars 2110, 2120 and bottom and side toolbars 2140, 2150. Such menus and toolbars include a set of icons that the user can select, each icon associated with one or more operations or functions as known in the art. Some of these icons are associated with software tools suited to editing and / or working with 3D modeled objects 2000 displayed in GUI2100. Software tools may be grouped into workbenches. Each workbench contains a subset of software tools. In particular, one of the workbenches is an Edition Workbench suited to editing the geometric features of a modeled product 2000. During operation, the designer may, for example, pre-select a portion of the object 2000 and begin working on it (e.g., changing dimensions, color, etc.), or select the appropriate icon to edit geometric constraints. For example, a common CAD operation is modeling punching or folding of a 3D modeled object displayed on the screen. The GUI may, for example, display data 2500 related to the displayed product 2000. In the example shown, the data 2500 displayed as a "function tree" and its 3D representation 2000 relate to a brake assembly including a brake caliper and disc. The GUI may further display various types of graphic tools 2130, 2070, and 2080 for, for example, facilitating the 3D orientation of objects, initiating a simulation of the operation of the product being edited, or rendering various attributes of the displayed product 2000. The cursor 2060 may be controlled by a haptic device that allows the user to interact with the graphic tools.

[0042] Figure 3 shows an example of a system, which is a client computer system, such as a user's workstation.

[0043] The client computer in this example includes 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 includes a video random access memory 1100 and associated graphics processing unit (GPU) 1110 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 clearly embodying computer program instructions and data include all forms of non-volatile memory, such as semiconductor memory devices like EPROMs, EEPROMs, and flash memory devices; magnetic disks like internal hard disks and removable disks; magneto-optical disks; and CD-ROM disks 1040. Any of the above may be complemented or incorporated by specially designed application-specific integrated circuits (ASICs). A network adapter 1050 manages access to the network 1060. The client computer may also include haptic devices 1090, such as a cursor control device and a keyboard. A cursor control device is used in 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 several signal generating devices for inputting 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 pressure-sensitive pad and / or a pressure-sensitive screen.

[0044] A computer program may include instructions that can be executed by a computer, and the instructions may include means for causing the system to execute the 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 device, for example, a product tangibly embodied in 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, manipulates input data, and generates outputs to perform the functions of the method. 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 them. The application program may be implemented in a high-level procedural programming language or an object-oriented programming language, and may be implemented in assembly language or machine language as needed. In any case, the language may be a compiled or interpreted language. The program may be a full installation program or an update program. When the program is applied to a system, in any case instructions are issued for executing the method.

[0045] Refer again to Figure 1 to further illustrate the flowchart of an example computer implementation method for designing the envelope of a modeled object.

[0046] The term "envelope of a modeled object" refers to any geometric representation that encloses a modeled object. More precisely, an envelope is a geometric representation that covers the outer surface of a modeled object without intersecting it. Therefore, in geometric space, the elements that make up the envelope (such as mesh faces or parts of a bounding volume) belong to the complement of the outer boundary of the geometric representation of the modeled object. Thus, the envelope of a modeled object has a similar shape to the modeled object. In other words, the envelope maintains similar characteristics, namely the geometric or topological features that indicate the shape of the modeled object within the geometric space in which the modeled object is defined. To put it another way, the envelope maintains the design intent of the modeled object and discards non-essential structural elements of the modeled object. Therefore, "non-essential" means that the aforementioned structural elements of the modeled object are not included in the designer's specifications regarding the use and purpose of the real-world object that the modeled object is supposed to represent. For example, the envelope may be a boundary that encloses the outer volume of a 3D object, and therefore all invisible geometry may be discarded. In yet another example, an envelope could be a boundary surrounding the area outside of 2D geometry. The level of detail of such a boundary may differ from that of the boundary of a 3D object (for example, it may have lower resolution).

[0047] A modeling object is provided (S10), and the modeling object is discretized into a grid of cells. Discretization of the modeling object may be performed before provision, i.e., a discretized modeling object is provided. Alternatively, the modeling object may be discretized after it has been provided to the system performing the method. Providing a modeling object means that the data defining the object is available to the system. The term “discretized into a grid of cells” refers to the domain space of the modeling object that is “cut out” (or tessellated) by geometric elements, which may be 3D geometric elements (such as polyhedra) or 2D geometric elements (such as polygons) if it is a 3D grid. The grid of cells may typically be a grid used in the finite element method, finite volume method, or finite difference method. The grid may be a regular grid, i.e., all cells in the grid are congruent and have the same shape and size. Examples of grids of cells known in the art are given below. It should be understood that the method defined in the claims is not limited to these examples and that any grid of cells can be used. The grid of cells may be a Cartesian coordinate system grid where the geometric elements are unit squares (2D geometric elements) or unit cubes (3D geometric elements). The grid of cells may be a linear grid with tessellation by rectangles (2D geometric elements) or cuboids (3D geometric elements, also called parallelepipeds). The grid may be a slanted grid with tessellation by parallelograms (2D geometric elements) or parallelepipeds (3D geometric elements). The grid may be a curved grid similar to a regular grid, where the cells are quadrilaterals (2D geometric elements) or hexahedrons (3D geometric elements). Thus, each cell of the grid consists of faces separated by the grid. A discrete coordinate system can be determined on the grid, and each cell of the grid is identified by individual coordinates along the dimensions of the grid.Two cells are adjacent if at least one of the coordinates (along the grid dimensions) of one cell is one or the other of the coordinates of the other cell. Two cells are directly adjacent if only one of the coordinates of one cell is one or the other of the coordinates of the other cell. In other words, in a discrete coordinate system containing discrete values ​​separated by cell size, the directly adjacent cells of a particular cell are those whose distance coordinates to that particular cell differ by the size of that cell. The periphery around a cell may be defined according to the coordinate system. The size of the periphery may be set according to the size value of any coordinate on the grid. Thus, the periphery around a cell may be determined by all cells whose coordinate values ​​have a coordinate difference from the coordinates of the cell that is less than the size of the periphery.

[0048] The cell grid resolution defines the level of detail in the discretization. The cell grid resolution is the size of the cells in a regular grid. For example, gaps in the model smaller than the grid resolution may be ignored. The grid resolution can be user-defined, allowing control over the level of detail in the discretization. The grid resolution may also be defined automatically, for example, by considering the size of the minimum gap in the modeled objects.

[0049] The elements of the cell grid may be grouped into sets of grid cells of the same category. Referring again to step S10, the cell grid includes a first set of cells that intersect with the modeling object and a second set of empty cells. Thus, the resulting cell grid consists of two sets of grid cells of the same category. The cell grid may contain cells of one or more categories.

[0050] A “set of cells” can be any data structure that represents one or more collections of cells in a grid of the same category. Thus, this method performs a set operation on a category of a first set of cells, a second set of cells, or any other set of cells described by this method. A set of cells may be empty, meaning it has no cells belonging to it, or it may contain one or more cells.

[0051] The cells in the grid that are added to the set of cells are identified in the cell grid, and once identified, they are added to the set of cells.

[0052] The elements of the first set of cells are the cells that intersect with the modeling object, i.e., the volume of the grid that geometrically intersects with the modeling object in space. For example, the intersection between a cell and a modeling object may consist of the intersection of at least one point of the modeling object and at least one point of the cell's face. The second set of empty cells obtained by discretization consists of the cells of the grid that belong to the complement (in the theoretical sense of a set) of the first set of cells. Thus, the cells that belong to the union of the two sets are all the cells of the grid obtained through the providing step S10.

[0053] When the provided steps are executed, N layers of cells are added adjacent to the modeled object. As mentioned earlier, N is a positive integer representing the number of layers to be added. Two substeps are executed. The first substep concerns the addition of N-1 layers, and the second substep concerns the addition of the Nth and final layer. The addition of the Nth layer is performed after the N-1 layers have been added.

[0054] Adding N-1 layers (for example, the first layer is added when p=1, the second layer when p=2, the third layer when p=3, etc.) can be thought of as an iterative process in which layers are added sequentially, and for each layer, the following is done: - Identify the intersecting cells in the first set and the adjacent empty cells in the second set; and, - Add the identified second set of cells to the first set of cells.

[0055] Identified adjacent cells are understood as adjacent cells in terms of the coordinates identified on the grid. Thus, this method associates the empty cells surrounding the cells of the discretized object with the first set of new cells. Since this method is performed sequentially, this is equivalent to adding material to the modeled object.

[0056] Therefore, the N-1 layers added in step S20 cover the modeled object. In particular, the N-1 layers cover small gaps in the modeled object, allowing for the removal of unnecessary details while maintaining the user's design intent. In fact, the N-1 layers added to the grid can merge gaps (represented as empty cells) in the cell grid if the number of consecutive cells constituting the gap is less than the "gap size" (the number of consecutive cells that make up the gap) of the added N-1 layers. Thus, the number of layers determines the extent to which the envelope discards unnecessary details. In the example, the user sets the value N so that the added layers cover a determined gap size, and therefore, by covering gaps smaller than that gap size, the complexity of the modeled object is reduced, and details within the gaps do not need to be retained; the details within the gaps are defined by the gap size. For example, the user may set how this method closes gaps by setting the value N according to the gap size as N = ("gap size" / 2) + 1. The value N may also be set by automatically determining the gap size. Furthermore, because this method involves sequentially adding elements from the discretized model objects, it preserves the non-convex regions of the modeled objects.

[0057] Once N-1 layers have been added, a second substep of the adding step S20 is performed, which is to identify the empty cells in the second set that intersect with the cells in the first set and are adjacent to them, and then add the identified empty cells in the second set to a third set of cells, thereby adding the Nth layer (the last layer). Thus, the Nth layer is added by identifying empty cells in the grid, following the same principle as the previous layers were added, except that the identified empty cells are added to a third set of cells, unlike the first and second sets. The Nth layer is added by performing the following: - Identify the intersecting cells in the first set and the adjacent empty cells in the second set; - Add the empty cells from the identified second set to the third set of cells.

[0058] The method then performs step S30, which calculates one or more contiguous sets of cells in the third set. A “contiguous set” means any set containing adjacent cells in the grid, i.e., the elements of the cells define a contiguous connection between adjacent cells in the grid.

[0059] Next, the method identifies one or more contiguous sets surrounding the discretized modeled object (S40). "Surrounding" means that the connections of adjacent cells constituting the contiguous set form a closed discrete shape having cells of a first set inside; where cells of the first set include cells intersecting the modeled object and material added in step S20. The closed shape may be determined via the discrete boundary method to ensure that cells of the first set belong inside the discrete boundary. "Retaining" means that cells of a third set that do not form a contiguous set surrounding the discretized modeled object are removed from the third set.

[0060] Next, the method performs step S50, which reduces the first set of cells. The addition of layers performed in step S20 is equivalent to adding material to the modeled object. A similar analogy would be that the modeled object was "heated" by the previous methods, and then "expanded" by adding layers of material. Therefore, step S50 of the method is equivalent to "cooling" the discrete modeled object, and for each N-1 layers added, the following is performed: - Identify the cells of the first set and the adjacent cells of the third set; - Add cells from the first set that have the identified third set of cells as adjacent cells to the third set of cells.

[0061] Since only cells constituting one or more consecutive sets are retained, this method sequentially adds cells constituting the added material to one or more consecutive sets surrounding the discretized modeled object.

[0062] Next, the method calculates the envelope of the modeled object based on the remaining cells of the grid, which belong to a third set (S60). Structurally, the cells of the third set enclose the discretized modeled object. In particular, the method obtains an envelope that does not open up the gaps in the original model, covered by the N-1 layers added in step S20. Thus, the method calculates an envelope that removes detail (i.e., the gaps covered by the added N-1 layers) while maintaining the main geometric and topological features of the modeled object that maintain the design intent, i.e., the use and purpose of the modeled object. Such an envelope may be used as a review step during the design process, or after the design process for review or presentation, and the process is highly interactive because the frame rate is improved thanks to the simplified envelope geometry. In practice, the envelope renders less detail than the modeled object (e.g., removal of internal geometry or reduction of external detail) thanks to the addition of layers covering gaps in the model of less than N size, which improves the ergonomics of the design process for the user.

[0063] In the example, step S40, which identifies one or more contiguous sets surrounding a discretized modeling object, further includes determining whether the determined one or more contiguous sets are surrounded by one or more other determined contiguous sets. Thus, step S40 determines whether the cells constituting each contiguous set are bounded by the cells of other contiguous sets, i.e., whether the cells of each contiguous set belong inside the discrete boundary of the other surrounding contiguous sets. Thus, the method can identify the outermost contiguous set that is not surrounded by other contiguous sets, i.e., the discrete shape of the cells of a third set surrounding the set is impossible. The inner contiguous sets are any of the contiguous sets surrounded by the outermost contiguous sets. Thus, the outermost contiguous sets can define candidate envelopes that surround the modeling object in a closed shape. Since a closed shape has a closed topology, the candidate envelopes can help provide a smooth envelope.

[0064] When one or more contiguous sets are surrounded by one or more other contiguous sets, the cells of the surrounding contiguous sets are removed from the cells of the third set and added to the fourth set of cells. Thus, this method can identify the material added to the modeled object in step S20 and extended into the interior of the modeled object. This method can identify the internal geometry of the modeled object and any internal geometry that may have remained from the gaps covered by N-1 layers in step S20. This is due to the fact that, structurally, a contiguous set added to the fourth set of cells is always between the cells representing the added material and the empty cells of the second set, and the said contiguous set is also surrounded by the outermost contiguous set.

[0065] In this example, the set of contiguous sets belonging to the fourth set of cells calculated in step S40 allows for precise cooling of the modeled object, because the cooling can be determined from the outermost contiguous set and the inner contiguous set that identifies the internal geometry. Following this example, step S50, which reduces the cells of the first set, includes the following for each N-1 layers added: - Identify the cells of the first set and the adjacent cells of the third set; - Add a cell from the first set that has a cell from the identified third set as an adjacent cell to a cell in the third set; And furthermore, this includes: - Identifying the cells of the first set and the adjacent cells of the fourth set; - Adding a cell from the first set that has an identified fourth set of cells as an adjacent cell to a cell in the fourth set; Therefore, this method identifies the adjacent cells that should be reduced for each cell in the layer. Any other cells in the first set that do not satisfy this condition are necessarily surrounded only by cells in the first set. To handle this situation, step S50 further performs the following: -For each cell in the first set that does not have any adjacent cells from the identified fourth set or the identified third set: Determine the cells surrounding the cell in question, thereby forming the periphery of the cell; If any cell in the peripheral region of a cell intersects with a cell in the third set or the second set, add that cell to the third set of cells; or, If no cells in the vicinity of a cell intersect with any cells in the third or second set, add that cell to the fourth set of cells.

[0066] Therefore, this method defines a perimeter around each cell in the first set surrounded by the added material. The perimeter around a cell can be determined by identifying cells whose coordinate difference from the cell's coordinates is smaller than the size of the perimeter. Thus, this method determines whether a cell is added to the third or fourth set by using the defined perimeter to check whether the perimeter intersects with cells in the third or fourth set. Thus, this method reduces the first set of layers for the outer and inner contiguous sets. This makes it possible to calculate an envelope with reduced complexity for the modeled object while maintaining the design intent. In fact, by reducing the first set of layers for the outer and inner contiguous sets, this method does not open up gaps covered by the added N-1 layers. Thus, the envelope is an envelope with further reduced complexity for the modeled object while maintaining the design intent. As a result, there is less geometry that needs to be rendered, and the design process is further improved ergonomically.

[0067] In the example, the formation of the periphery may be performed by tracing multiple rays starting from a first set of cells and identifying the cells in an added layer where the rays intersect. The added layer is one of the N layers added in step S20, which contain the cells of the first set. The cells on which the rays are traced belong to the added layer. The rays may be calculated in any direction, but only the cells that intersect with the rays and belong to the layer of cells from which the rays are emitted are considered for the formation of the periphery. That is, the traced rays stop when they hit cells that are not part of the N-1 layers, and the rays pass only through the cells of the added layer. "Tracing" means calculating one or more line representations of lines in the geometric space of the modeled object in this method, where the lines start from a point in space that intersects with the cells of the first set, and include size and direction. Each of the one or more line representations may be traced starting from the starting point, of any size, and in any direction, for example, in multiple independent directions. An arbitrary starting point may be defined, for example, a point in geometric space corresponding to the midpoint of a cell. Next, in this method, the periphery of a cell is formed by the identified cells where rays intersect. Intersections can be confirmed in terms of coordinates by first discretizing the rays and identifying the cells where they intersect. Next, this method can form the periphery of a cell by the identified cells where rays intersect. In particular, this method does not always need to trace all possible rays starting from a point. In fact, tracing can stop if a cell is hit that is not part of the layer currently being processed (i.e., if the rays intersect). Then, in this method, if the cell where the rays intersect is a cell in the third set or the fourth set, that cell is added to the third set of cells; otherwise, the cell is added to the fourth set of cells.

[0068] In the example, forming the periphery of the set may include adapting and changing the periphery size as step S50 is performed for each added layer. For example, step S50 may initially set a periphery size l of size N and form the periphery of the cell by tracing rays of that size. Step S50 may start with a periphery size l=N for layer p corresponding to p=N-1. This method can be continued for each added layer p=N-1, p=N-2 by reducing the length of the traced rays accordingly (for example, l=N-1 for p=N-2). Other types of reduction may be performed that can improve the adaptive calculation of the periphery. For example, this method may adaptively modify the periphery of the cell using a pseudo-annealing method.

[0069] In the example, the method further includes decimating a third set of cells surrounding the discretized modeled object before calculating the envelope. Decimation is performed by: identifying cells in the third set that have only cells belonging to the second or third set of cells as their neighbors, and adding the identified cells to the second set of cells. Thus, the method retains only the cells of the envelope adjacent to empty space, that is, it ensures that the envelope is a wrapper consisting only of the outermost cells surrounding the modeled object. Thus, the method avoids having multiple layers wrapping the discretized modeled object, thereby reducing the computational load when rendering the modeled object. Thus, the method generates a more detailed envelope that can be rendered more easily, thereby further improving the design from an ergonomic standpoint.

[0070] This method may further resolve the details of the candidate envelope after the reduction step S50 and before the calculation step S60 by pushing the candidate envelope into the internal space covered by the added material. In the example, the method pushes the candidate envelope by inserting one or more contiguous sets of cells from a third set surrounding the discretized modeling object. This is done as follows: - Identify the cells of the third set and the adjacent cells of the fourth set; and, - Add the identified fourth set of cells to the third set of cells.

[0071] In other words, the method first identifies the cells of a candidate envelope that will cover the gap. In fact, by the reduction step S50, the cells of the fourth set with adjacent cells of the third set are necessarily the cells inside the covered gap. Next, the method pushes the envelope into the covered gap. Thus, the method outputs a more precise envelope that shows relatively more detail of the gap without losing the single closed shape of the candidate envelope.

[0072] The method can further calculate the envelope of the provided modeled object from the remaining cells of a third set. The method can ensure that the calculated envelope does not contain anomalies such as undesirable intersections between the modeled object and the envelope. In the example, calculating the envelope of the provided modeled object from the identified third set of cells further includes: identifying the cells of the third set that have an empty cell as an adjacent cell in the second set of cells; and calculating the envelope of the provided modeled object from the identified third set of cells. Thus, the method ensures that the envelope does not intersect with the cells of the first set, thus preserving the design intent of the modeled object.

[0073] This method may be applied to compute the envelope of a 2D or 3D modeled object. In practice, this method may be applied to any method known in the art that allows discretization of cells into a grid. For example, the provided modeled object may be 2D geometry, and the grid of cells may be a 2D grid, where adjacent cells are coordinately adjacent in either the x or y direction. Thus, this method may be carried out by involving the computation of the coordinates of the grid of cells in Cartesian space. In another example, the provided modeled object may be 3D geometry, and the grid of cells may be a grid of voxels, where adjacent cells are coordinately adjacent in either the x, y, or z direction. Thus, this method may be carried out by performing the computation of adjacent cells in the grid of cells in Euclidean space.

[0074] Thus, this method can output an envelope according to the input modeled object. The calculated envelope may be a wrap consisting of a 3D mesh representation, or a bounding perimeter in 2D space. For example, if the provided modeled object is a 2D geometry represented as a bitmap and the cell grid is a 2D grid, the envelope may be calculated by converting the cells into a set of 2D lines. Similarly, for 3D modeled objects, if the provided modeled object is a 3D geometry consisting of a mesh and the cell grid is a voxel grid, the envelope may be calculated by converting the identified cells into a quadrilateral mesh.

[0075] In the example, if the provided modeling object is 3D geometry, the envelope of the provided modeling object may be calculated by converting the faces of each cell in a third set adjacent to a second set of cells into a quadrilateral mesh. Thus, this method produces a single envelope mesh that wraps the input 3D geometry with a spherical topology, covering the gaps in the model and appropriately capturing the non-convex regions. When the indentation step is performed, the wrap mesh is pushed into the interior of the gaps covered by the envelope, so the resulting wrap can be very accurate. The envelope may also be used to create the geometry of an imposter by baking the texture of the modeling object. In particular, this method can create an envelope such that there are no undefined regions with respect to the texture content of the imposter, making it possible to obtain the geometry of an imposter with a clearly defined texture.

[0076] Here, we describe an example of a data structure for storing a grid of cells. A grid of cells represents a discretized modeling object. The data structure stores a grid of cells divided into subgrids of the same size. All subgrids together cover the entire grid, and each subgrid uniquely covers a portion of the grid without overlap. For each subgrid, the data structure further includes one or more pointers indicating at least one of the first, second, third, and fourth sets of cells described herein.

[0077] In the example, the first, second, third, and fourth sets of cells may be split into several that refer only to voxels in the same subgrid. This reduces the memory usage required to address the subgrid. To illustrate this, a subvolume (of a 3D grid) containing 32 voxels in each dimension (x, y, z) of the subvolume would have a total of 32,768 voxels per subvolume of the 3D grid. To address the entire volume by (x, y, z) coordinates, one can use three 32-bit integers (one for each coordinate), or a 64-bit integer if the index is serialized (i.e., (z*(width*length)+y*width+x)). Thus, if the first, second, third, and fourth sets of cells are split, the coding of the subvolume pointers that point to the cells enumerated in each set of cells of the subvolume will not exceed a given size.

[0078] As already explained, this method relies on (or uses) the state of adjacent cells when assigning a cell to one of a set of cells. Thus, a set of cells can refer to each cell by its (x, y, z) vector, and the cell's (x, y, z) vector represents the cell coordinates using the (x, y, z) dimension of the subvolume.

[0079] In the example, the grid is divided into subcells of the same size, with 32 cells for each (x, y, z) dimension of the grid, resulting in a total of 32,768 voxels per subvolume, as in the previous example. The (x, y, z) position of a cell in a subgrid can be encoded in 15 bits, which is large enough for a pointer to address an entire subgrid. In one example, the 15-bit encoding may be used as follows: Understand that the range of each coordinate in the subgrid is 0 to 31 (also written as [0;31]), and reserve 5 bits for each coordinate. This allows us to use a single 16-bit integer instead of three 16-bit integers to refer to a cell, thus saving even more memory.

[0080] Next, we will describe an example of the data structure for a subgrid. In this example, the subgrid is a subvolume of 32 voxels for each (x, y, z) dimension of the subvolume. The declaration struct defines a list of variables for a memory block named SubVolume. Several variables are enumerated and can be accessed using pointers. struct SubVolume { int8_t *voxelStatesPtr; / / A 64-bit pointer to 8192 bytes if the 32768 voxels are in a non-uniform voxel state. int8_t homegeneousState; / / 1 byte if subvolume is uniform }; / / => 72 bytes per subvolume int32_t volumeDim[3]; / / Number of voxels in each x, y, and z direction std::vector <subvolume>semiSparseVoxelGrid;

[0081] The data structure has 9 bytes for a uniform subvolume. A uniform subvolume contains only cells (voxels) that belong to the same set of cells. Therefore, since all voxels belong to the same set of cells, no memory is allocated to voxels. For a non-uniform subvolume, an additional 8192 bytes are dynamically allocated, with each byte encoding four voxels from the same set of cells. A non-uniform subvolume contains cells (voxels) that belong to two or more sets of cells.

[0082] As more layers are added during the heating step, the previously sparsely filled sub-volumes become full, and some of them eventually become uniform, requiring only 9 bytes, thus the new data structure is significantly more memory efficient.

[0083] The data structure is at least 10 times more memory-efficient than the conventional sparse voxel representation. The most memory-efficient sparse voxel volume is a map with a 64-bit integer for a 63-bit encoded (x, y, z) vector and a 1-byte key for each voxel state (i.e., 1 byte to identify one of the four sets of voxels to which the voxel belongs), occupying 9 bytes per voxel. This means that 1023 voxels require the same amount of memory as one non-uniform subvolume containing 32768 voxel states. For example, referring to the car envelope shown in Figure 33, the conventional data structure would require 24GB of memory just to represent 321 million geometric voxels. Furthermore, a lot of time is spent accessing a specific voxel state. Using a map means that the key is looked up every time a voxel state is accessed. In the best-case scenario, this occurs in constant time, but there is additional memory usage (the time complexity of std::map is O(log(n)) and the time complexity of std::unordered_map is O(1), but requires more memory for the internal hash table). The data structure of the present invention occupies 289945 non-uniform subvolumes of 8192 bytes each for its geometry, which is about 2.2 GB of memory, and accessing each voxel state takes constant time (O(1)).

[0084] The combinations of the examples described above will be discussed with reference to Figures 4-8. Please understand that these combinations do not preclude other combinations of the examples described above. Although Figures 4-8 relate to 3D modeled objects and 3D grids, they can be applied to 2D modeled objects and 2D grids without significant structural changes.

[0085] Figure 4 shows steps S10-S60 of the method described with reference to Figure 1. In the following description, the term "state" is used to refer to the set of cells to which a grid cell belongs. The four states that identify each set are as follows: • STATE_MATTER (state of matter) identifies the first set of cells. • STATE_VOID (empty state) identifies the second set of cells. • STATE_WRAP (wrap state) identifies the third set of cells. • STATE_INTERIOR (internal state) identifies the fourth set of cells.

[0086] As shown in Figure 4, step S10 includes the initialization of the cell grid S210 and the discretization step S220. Since this example consists of a 3D modeled object, the cell grid may also be a grid of voxels. In step S210, the user first defines the cell grid and specifies the parameter "cell size", which implicitly defines the dimensions of the cell grid of the complete modeled object. In addition to the cell size parameter, the user may specify the dimensions of the cell grid. Alternatively, the user may set the "cell size" parameter automatically and define only the dimensions of the cell grid. In step S210, all cells in the grid are initialized with STATE_VOID, and therefore all cells are empty.

[0087] In step 220, the state of each cell in the grid that intersects the geometry of the modeled object is set to STATE_MATTER, and the modeled object is discretized.

[0088] As a result of S210 and S220, each cell in the grid is associated with one state selected from STATE_VOID, which corresponds to a second set of cells, and STATE_MATTER, which corresponds to a first set of cells.

[0089] Next, in step S20, N layers are added to the modeled object. The sequential addition of adjacent layers simulates a heating process in which the material of the modeled object expands due to the rising temperature of that material. The sequential addition starts from the cells of the discretized modeled object. The sequential addition of adjacent layers stops when N layers have been added. Two consecutive layers are adjacent, and each cell of the Np-th layer shares a common edge (a 2D geometric element) or a common face (a 3D geometric element) with at least one geometric element of the N-(p+1)-th layer. The number of added layers N is set as N = ("gap size" / 2) + 1, so the user may pre-specify a parameter, "gap size," which determines the extent of the gap that should be closed by the envelope. If the gap in the modeled object is closed by the added layers, the material is "melted" and will not be pulled apart during the reduction step.

[0090] As shown in Figure 4, step S20, which adds N adjacent layers to the modeled object simulating the heating process, includes adding N-1 consecutive layers of material in step S230, followed by adding an Nth layer consisting of wrap cells in step S240. In step S230, material (i.e., cells in the state STATE_MATTER) is added to the modeled object by adding a corresponding adjacent cell layer (adjacent in either the x, y (or z) direction) to each cell having the state STATE_MATTER. The x, y directions are the directions of the 2D grid, and the x, y, z directions are the directions of the 3D grid. Step S230 is performed N-1 times consecutively.

[0091] Figure 5 illustrates step S230 in more detail. For each cell that has a state of matter, it is determined whether its neighboring cells are empty. If no, the state of the neighboring cells is not changed (i.e., the state of the neighboring cells remains STATE_VOID). If yes, the state of the neighboring cells is changed to the state STATE_MATTER.

[0092] After executing S230 N-1 times, step S240 adds an Nth layer following the same principle as step S240. For each cell with STATE_MATTER, it is determined whether its neighboring cells are empty. If no, the state of the neighboring cells is not changed (i.e., the state of the neighboring cells remains STATE_MATTER). If yes, the state of the neighboring cells is changed to STATE_WRAP. Cells with the STATE_WRAP state are the cells that form the initial estimate of the future envelope that will wrap the input 3D geometry. Since matter extends into the interior of the modeled object (in fact in any direction), there may also be cells that form an envelope surrounded by other formed envelopes.

[0093] To address this, steps S30 and S40 are then executed. Essentially, step S30 first determines the candidate envelopes, and the next step S40 removes the candidate envelopes that are surrounded by other candidate envelopes, thereby leaving only the outer envelope of the modeled object.

[0094] Figure 4 illustrates step S30 in more detail, determining a set of contiguous cells having the state STATE_WRAP (S250). Step S30 determines a set of elements that are adjacent cells in a grid, i.e., the elements of that set share a common edge (in the case of a 2D grid) or face (in the case of a 3D grid). A set of contiguous cells can be considered a candidate envelope. Since the material is stretched in all directions, a cell having the state STATE_WRAP forms one or more sets of contiguous cells, including sets of contiguous cells surrounded by other determined sets of contiguous cells. Next, Figure 4 shows the details of step S40. A set of consecutive cells surrounded by an outer set of consecutive cells is removed by performing step S260 for each set of consecutive cells having the STATE_WRAP state. Step S260 determines whether the set is surrounded by another set of consecutive cells having the STATE_WRAP state. The determination may be made by constructing a polygon formed by the cells of the consecutive sets and performing polygon boundary detection on a 2D grid, or similarly by constructing a polyhedron on a 3D grid, or by any similar method. If it is determined that the set is surrounded by another set of consecutive sets, the state of the cells in that set is set to STATE_INTERIOR.

[0095] Step S40 performs step S260 for each set of contiguous cells that have the STATE_WRAP state, so that only the outermost set of contiguous cells remains, thereby forming a candidate envelope. Each candidate envelope is topologically closed.

[0096] Next, step S50 is performed, which is detailed in Figure 4. The successive reduction of N-1 layers of added material simulates a cooling process in which the previously expanded modeled object is now contracted. Step S50 begins with the N-1th added layer, and step S270 is performed for the corresponding i layers to be removed, where i is a positive integer that decreases successively from i=N-1 to i=0 (i.e., i=N-2, i=N-3, etc.). As shown in Figure 4, step S50 performs process S270, which is performed for each corresponding i-th layer to be removed. Process S270 is detailed in Figure 6. Process 270, which reduces layers, is performed by checking the state of the periphery of each cell in the corresponding layer to be removed. First, for each cell in the corresponding layer to be removed, each adjacent cell (not part of the current layer) is checked. If such an adjacent cell is STATE_WRAP, the state of the processed cell is set to STATE_WRAP. If such adjacent cells are STATE_INTERIOR, the state of the processed cell is set to STATE_INTERIOR. Otherwise, the cell should be surrounded by either a cell with the state STATE_MATTER or a cell in the corresponding layer to be deleted. In that case, rays are emitted from the processed cell in all directions. If the rays hit a cell that is not part of the corresponding layer to be deleted, the ray tracing stops. If the rays hit (i.e., intersect) a cell with STATE_VOID or STATE_WRAP, the processed cell is set to STATE_WRAP. Otherwise, it is set to STATE_INTERIOR. This test is necessary to prevent gaps that have melted during the heating step from opening.

[0097] At the end of the reduction step, there may be multiple layers of cells with STATE_WRAP, including the outermost set of cells of the contiguous set determined in step S40. Figure 4 illustrates the indentation and subsequent decimation processes performed after step S50 and before the calculation of the envelope in step S60, which thins the envelope and allows some details to be resolved before the envelope is calculated. This process is described below.

[0098] As shown in Figure 4, after step S270, a parameter P called the "depth of intrusion" is obtained. Parameter P must be a positive integer. The number P sets the number of iterations to be performed. Thus, step S280 can be performed P times and repeated with an index i that starts from 0 and increases continuously until it reaches a positive integer P times earlier (i.e., i=0, i=1, i=2, etc.). Step S280 consists of an intrusion process followed by a decimation process, which is illustrated in Figures 7 and 8. The intrusion process is any process, and the decimation process may be performed independently. However, in this example, process S280 first performs the intrusion process, followed by the decimation process of step S281.

[0099] The process of inserting S280 is detailed in Figure 7. Step S280 is essentially to "push" a cell having the state STATE_WRAP into an "internal space" composed of cells having the state STATE_INTERIOR via parameter P. Thus, step S280 makes it possible to resolve some of the details of the candidate envelope. As shown in Figure 7, step S280 examines each adjacent cell of each cell having the state STATE_WRAP. If the state of an adjacent cell is STATE_INTERIOR, the adjacent cell is set to STATE_WRAP. Otherwise, the state of the adjacent cell remains unchanged. Next, step S281 is performed.

[0100] The decimation process in step S281 is shown in Figure 8. The decimation process essentially discards duplicate (or multiple) layers of cells in the STATE_WRAP state. For each cell in a layer of cells with the STATE_WRAP state, it is checked whether the cell has only neighboring cells in the STATE_WRAP or STATE_VOID state. If so, the cell's state is added to STATE_VOID; otherwise, the state is left unchanged.

[0101] Next, step S60 is performed. Figure 4 shows details of step S60, which performs the extraction of the envelope described by process S290.

[0102] This method examines each side of each remaining cell with the STATE_WRAP state (for example, the cell's edge in a 2D grid, or the voxel's face in a 3D grid) to check if the adjacent cell has the STATE_VOID state. If so, the cell is added to the final envelope being calculated. This is done for all remaining cells with the STATE_WRAP state. This ensures that the wrapped mesh does not intersect with any cells of STATE_MATTER. Next, step S60 converts the added cells into an envelope, for example, a quadrilateral mesh.

[0103] Figures 9-14 show the steps for calculating the envelope of a 2D modeled object in a 2D grid, with decimation performed before the envelope calculation. The grid is initialized with a "gap size" of 1, and the number of added layers (heating steps) N is set to 2, so the number of reduction steps is N-1=1. Figure 9 shows step S10 with the initial 2D model discretized in a grid of cells. In Figure 9, the cells of the first set are shown in black C90, and the cells of the second set of empty cells are shown in white C91. Figures 10-11 show the two layers p=1 and p=2 added according to step S20. The added layers of the first set of cells are shown in black, indicating the material added in all directions from the modeled object. Thus, Figure 10 shows the added layer p=1. Figure 11 shows the layer p=2 added afterwards. Thus, the cells of the layer added with p=2=N are the cells of the third set. Figure 12 shows the consecutive sets determined in steps S30 and S40, which are indicated in dark gray C92. Figure 13 shows the reduction step S50, where the dark gray cells represent the "cooling" process achieved by step S50. Figure 14 shows that the outer dark gray scale has been removed after the thinning step has been performed. Step S60 is not shown in the image.

[0104] It can be seen that one or more contiguous sets (cells with a STATE_WRAP state, shown in dark gray) surrounding a discretized modeled object do not surround any other contiguous sets. Figures 15-32 show cases where one or more contiguous sets are surrounded by one or more other determined contiguous sets.

[0105] Furthermore, the examples shown in Figures 15–32 illustrate the calculation of an envelope that includes an intrusion step, followed by a decimation process after each iteration of the reduction step S50, before the execution of the intrusion process. In this example, the grid is initialized with a gap size of 2, the number of heating steps is N=5, the number of annealing steps is N-1=4, and the intrusion parameter is P=2. In this example, different sets of cells are shown using the same colors as in the previous example: black C90, white C91, and dark gray C92. Additionally, internal cells (i.e., cells of the fourth set of cells) are identified by light gray C93. Figure 15 shows step S10, where the initial model has been discretized into a voxel grid. Figures 16–20 show the successive addition of layers of black cells (added material) by step S20. Figure 21 shows a successive set of the third set of cells determined by step S30, in dark gray. Figure 22 shows the identified set of contiguous cells surrounding the modeled object, with the outer contiguous set remaining in dark gray and the enclosed contiguous set added in light gray. Figures 23–30 show each step of the reduction step S50, with the decimation process following each iteration of reduction step S50. Figure 23 shows the first iteration of reduction, illustrating how the material is cooled by one layer. Thus, there are two layers of dark gray cells. Figure 24 shows the decimation process applied after the first iteration of reduction step S50, where the cells of the outermost layer are set as empty cells. This is due to decimation identifying dark gray cells (cells of the third set) that have only sets belonging to a second or third set of cells (i.e., empty cells or other dark gray cells) in their adjacent cells. The cells of the outermost layer are precisely the cells that satisfy this condition. The same process is repeated in Figures 25–30. Figure 29 further shows the reduction step that performs ray emission within the model. In the lower right, the reduction leaves the internal cells of the model. Furthermore, the gap located in the upper right corner of the left model remains closed after the thinning shown in Figure 30.Figures 31 and 32 show the intrusion steps q=1 and q=2 of the intrusion process when the intrusion parameter P=2 is given. In both figures, the dark gray layer is shown being pushed into the internal space of the gap. The resulting envelope is relatively more detailed while maintaining a spherical topology.

[0106] Figures 33-35 show examples of vehicle model envelopes calculated according to this method. In these examples, the method uses a voxel grid with a voxel size of 6 mm. The resulting envelope is shown in Figure 33. The envelope consists of approximately 1.1 million voxels and does not include the internal geometry of the motor, etc. Changing the voxel size alters the model's resolution and memory requirements. With a voxel size of 0.5 mm, the discretized model has over 150 billion voxels, and the resulting envelope (not shown) consists of approximately 4.5 billion voxels. With a voxel size of 0.33 mm, a volume of approximately 600 billion voxels is required, resulting in an envelope consisting of 16 billion voxels. This method and data structure make it possible to implement this method on current commercial computers. Envelopes based on a 0.33mm voxel grid were calculated on a computer with 64GB of RAM, while envelopes based on a 0.5mm voxel grid were calculated on a laptop with 32GB of RAM.

[0107] Compared to the data structure used in this implementation, the conventional structure requires approximately 24 GB of memory to store 321 million geometric voxels of a discretized vehicle. This is in addition to the time spent accessing specific voxel states. Accessing specific voxel states and / or performing operations on voxel states can require significant computational resources. In fact, operations that use maps such as std::map mean that a key must be looked up each time a voxel state is accessed. In the best-case scenario, this occurs in constant time, but incurs additional memory usage. For example, the operation std::map has a time complexity of O(log(n)), and the operation std::unordered_map has a time complexity of O(1), but requires additional memory for the internal hash table. In contrast, the provided data structure occupies 289945 non-uniform subvolumes of 8192 bytes each for the geometry, which is approximately 2.2 GB of memory, and accessing each voxel state takes constant time (O(1)). Thus, the need for data storage is significantly reduced and access time is greatly improved.

[0108] By setting the gap size so that the layer added in step S20 of the method closes the gap that accesses the motor geometry, invisible geometry, such as the motor geometry, is discarded by the method. Figure 34 shows a comparison of gaps closed by the envelope with set gap sizes. On the left, the large opening indicated by R340 is shown to be closed by the envelope by selecting a large gap size. In contrast, on the right, the parameters were selected to close only a small gap, so the envelope passes through the opening R341 and also covers the motor geometry (not shown). Figure 35 shows a zoomed-in area of ​​the envelope in Figure 33. It shows how the envelope respects details in non-convex areas such as the mirror and its handle.

[0109] Figures 36-38 show examples of envelopes calculated from a 3D model of a bicycle. Figure 36 shows the original model on the left and the envelope on the right. The original model on the right consists of approximately 1.3 million triangles, while the calculated envelope is a single mesh consisting of approximately 32,000 triangles. Figure 36 further demonstrates that the envelope calculated by this method provides a sufficiently accurate and simplified model while respecting the design intent of the bicycle. In fact, this model can be considered an extreme example of an object with multiple holes to respect, which consist of empty spaces set by rays that form the wheel. The envelope on the left is a single envelope that individually encloses each ray of the bicycle wheel. Figure 37 shows zoomed-in areas of the wheels in both models, showing how each ray of the wheel is represented in the envelope mesh. Figure 38 shows the geometry of an imposter generated from the envelope, with the texture of the original model applied. In particular, although the imposter's geometry is coarser than the original model, the applied textures cover the individual rays of the bicycle without any texture anomalies.< / subvolume>

Claims

1. A computer-implemented method for designing the envelope of a modeled object, The aforementioned computer, - A step (S10) of providing a modeling object to be discretized into a grid of cells, thereby obtaining a grid containing a first set of cells intersecting with the modeling object and a second set of empty cells, - Step (S20) of adding N layers adjacent to the modeled object, defined as N = (gap size / 2) + 1 (where N is a positive integer) based on the provided value, "gap size," For N-1 layers, for each layer: - The steps of identifying an empty cell in a second set adjacent to an intersecting cell in a first set, and - The step of adding the identified second set of cells to the first set of cells; Execute, ...For the Nth layer: - The steps of identifying an empty cell in a second set adjacent to an intersecting cell in a first set, and - The step of adding the empty cells from the identified second set of cells to the third set of cells; Execute The additional step (S20), - A step (S30) of calculating one or more consecutive sets of cells in the third set, - The step (S40) is to identify one or more consecutive sets surrounding the discretized modeled object and to retain only the cells of the identified one or more consecutive sets in a third set, and the step of identifying the one or more consecutive sets is further, ...determine whether one or more determined consecutive sets are surrounded by one or more other determined consecutive sets. ...if enclosed, this includes removing the enclosed set of cells from the third set and adding them to the cells of the fourth set, For each N-1 layer added: ...Identify the cells of the first set and the adjacent cells of the third set, and add the cells of the first set that have the identified cells of the third set as adjacent cells to the cells of the third set. ...Identify the cells of the first set and the adjacent cells of the fourth set, and add the cells of the first set that have the identified cells of the fourth set as adjacent cells to the fourth set. ...For each cell in the first set that does not have identified adjacent cells in the third or fourth set, determine the cells surrounding the cell, thereby forming a perimeter of the cell, add the cell to the third set if any cell in the perimeter intersects with a cell in the third or second set, and add it to the fourth set if it does not intersect. The first step (S50) is to reduce the number of cells by performing the following, - A step (S60) of calculating the envelope of the provided modeled object from the third set of cells, - A storage step for storing the cells of the grid in a data structure, comprising: dividing the first, second, third, and fourth sets so as to refer only to voxels of the same subgrid; dividing the grid into equally sized subcells consisting of 32 cells for each [x, y, z] dimension; and encoding the [x, y, z] position of the cells in the subgrid with a total of 15 bits, with 5 bits assigned to each coordinate. Computer implementation methods, including those mentioned above.

2. The step of determining the cells surrounding the aforementioned cell is: - A step of tracing multiple rays from the first set of cells, - A step of identifying the cells of the additional N-1 layers where the light rays intersect, - The process includes the step of forming a peripheral area of ​​a cell by the cell through which the identified rays intersect, The computer implementation method according to claim 1.

3. The ray is traced with a length that decreases each time a first set of cells is reduced, and the initial length of the ray is the length of N cells. The computer implementation method according to claim 2.

4. Before calculating the envelope, perform decimation of a third set of cells surrounding the discretized modeled object: Identify a third set of cells whose adjacent cells consist only of cells belonging to the second or third set of cells; - Further includes performing decimation of the third set of cells by adding the identified cells to a second set of cells. The computer implementation method according to any one of claims 1 to 3.

5. Before calculating the envelope: - One or more contiguous sets of cells from a third set enclose the discretized modeling object: ...the step of identifying the cells of the third set and the adjacent cells of the fourth set, ...further comprising the step of inserting the identified fourth set of cells by adding them to a third set of cells. The computer implementation method according to any one of claims 1 to 4.

6. From the third set of cells, the envelope of the provided modeled object can be calculated: - A step of identifying a third set of cells that have a cell from a second set of cells as an adjacent cell, - A step of calculating the envelope of the provided modeling object from the identified third set of cells. A computer implementation method according to any one of claims 1 to 5, further comprising:

7. - The provided modeled object is 2D geometry, the cell grid is a 2D grid, and adjacent cells are coordinately adjacent in either the x or y direction; or, - The provided modeled object is 3D geometry, the cell grid is a voxel grid, and adjacent cells are coordinately adjacent in either the x, y, or z direction. The computer implementation method according to any one of claims 1 to 6.

8. The step of calculating the envelope of the provided modeling object from the identified third set of cells is: - If the provided modeling object is 2D geometry represented by a 2D vector image and the cell grid is a 2D grid, the step of calculating the envelope by converting the cells into a set of 2D lines; or, - If the provided modeled object is a 3D geometry consisting of a mesh and the cell grid is a grid of voxels, the step of calculating the envelope by converting the identified cells to a quadrilateral mesh; The computer implementation method according to claim 7, further comprising:

9. If the provided modeling object is 3D geometry, the envelope of the provided modeling object is calculated by converting the faces of each cell in the second set of cells and the adjacent third set of cells into a quadrilateral mesh. The computer implementation method according to claim 8.

10. A computer program comprising instructions for causing the computer to perform the method according to any one of claims 1 to 9.

11. A system comprising a memory storing the computer program described in claim 10, and a processor coupled to a graphical user interface.

Images