Patent Application
20230161927
This disclosure relates to the field of design and, more particularly, relates to three-dimensional (3D) modeling of a threaded feature using computer-aided design.
Computer-aided design (CAD) software can facilitate the design of a great many objects, some of which have threaded features. Prior methods of representing threaded features, particularly with cosmetic threads, in a computer-aided design environment were rudimentary and failed to adequately inform viewers of the true nature of any such threaded features. Other shortcomings exist in representing threaded features in a computer-aided design environment as well.
In one aspect, a computer-based method is disclosed of creating a visual representation of a threaded feature on a three-dimensional (3D) modelled object in a computer-aided design environment. The method includes constructing a helical curve and start and end circles for a threaded feature in a 3D modelled object, trimming the helical curve to conform to a geometry of the modelled object, identifying a boundary of the trimmed helical curve; and displaying a cosmetic thread to visually represent the threaded feature based on the trimmed helical curve and the identified boundaries of the trimmed helical curve.
In another aspect, a computer-based system is disclosed for creating a visual representation of a threaded feature on a three-dimensional (3D) modelled object in a computer-aided design environment. The computer-based system includes a computer processor and computer-based memory operatively coupled to the computer processor. The computer-based memory stores computer-readable instructions that, when executed by the computer processor, cause the computer-based system to construct a helical curve and start and end circles for a threaded feature in a 3D modelled object, trim the helical curve to conform to a geometry of the modelled object, identify a boundary of the trimmed helical curve; and display (on a computer display) a cosmetic thread to visually represent the threaded feature based on the trimmed helical curve and the identified boundaries of the trimmed helical curve.
In yet another aspect, a non-transitory computer readable medium is disclosed that has stored thereon computer-readable instructions that, when executed by a computer-based processor, cause the computer-based processor to: construct a helical curve and start and end circles for a threaded feature in a 3D modelled object, trim the helical curve to conform to a geometry of the modelled object, identify a boundary of the trimmed helical curve; and display a cosmetic thread to visually represent the threaded feature based on the trimmed helical curve and the identified boundaries of the trimmed helical curve.
According to another aspect, a computer-based method is disclosed of creating a visual representation of a threaded feature on a three-dimensional (3D) modelled object in a computer-aided design environment. The method includes establishing a thread definition for the threaded feature, processing data from the thread definition to support creating the visual representation of the threaded feature; and constructing thread geometry based on the thread definition and the processing of data from the thread definition. Constructing the thread geometry may include determining, with a computer processor, whether the thread definition identifies the visual representation as a cosmetic thread or a physical thread. If the computer processor determines that the visual representation is a cosmetic thread then the method includes constructing a helical curve and start and end circles for the threaded feature, trimming the helical curve to conform to a geometry of the modelled object, identifying a boundary of the trimmed helical curve; and displaying, on a computer display, the cosmetic thread to visually represent the threaded feature based on the trimmed helical curve and the identified boundaries of the trimmed helical curve.
In yet another aspect, a computer-based system is disclosed for creating a visual representation of a threaded feature on a three-dimensional (3D) modelled object in a computer-aided design environment. The computer-based system includes a computer processor and computer-based memory operatively coupled to the computer processor. The computer-based memory stores computer-readable instructions that, when executed by the computer processor, cause the computer-based system to: establish a thread definition for the threaded feature, process data from the thread definition to support creating the visual representation of the threaded feature, and construct thread geometry based on the thread definition and the processing of data from the thread definition. Constructing the thread geometry may include determining, with a computer processor, whether the thread definition identifies the visual representation as a cosmetic thread or a physical thread. If the computer processor determines that the visual representation is a cosmetic thread then, the method includes constructing a helical curve and start and end circles for the threaded feature, trimming the helical curve to conform to a geometry of the modelled object, identifying a boundary of the trimmed helical curve, and displaying, on a computer display, the cosmetic thread to visually represent the threaded feature based on the trimmed helical curve and the identified boundaries of the trimmed helical curve.
In still another aspect, a non-transitory computer readable medium is disclosed having stored thereon computer-readable instructions that, when executed by a computer-based processor, cause the computer-based processor to create a visual representation of a threaded feature on a three-dimensional (3D) modelled object in a computer-aided design environment by performing a method that includes establishing a thread definition for the threaded feature, processing data from the thread definition to support creating the visual representation of the threaded feature, and constructing thread geometry based on the thread definition and the processing of data from the thread definition. Constructing the thread geometry may include determining, with a computer processor, whether the thread definition identifies the visual representation as a cosmetic thread or a physical thread. If the computer processor determines that the visual representation is a cosmetic thread then the method includes constructing a helical curve and start and end circles for the threaded feature, trimming the helical curve to conform to a geometry of the modelled object, identifying a boundary of the trimmed helical curve, and displaying, on a computer display, the cosmetic thread to visually represent the threaded feature based on the trimmed helical curve and the identified boundaries of the trimmed helical curve.
In some implementations, one or more of the following advantages are present.
For example, in various implementations, the systems and techniques disclosed provide a relatively simple, efficient way of informing viewers of the true nature of a threaded feature in an object within a computer-aided design environment. Moreover, in various implementations, the systems and techniques disclosed herein provide a single interface that enables easy and efficient switching between a representation of a threaded feature appropriate for generating marketing materials or the like and a threaded feature appropriate for three-dimensional (3D) printing applications, for example. In a typical implementation, the cosmetic thread is trimmed to geometry created after the cosmetic thread is created, which is unlike most (if not all) other cosmetic thread representations that maintain the same representation irrespective of subsequent geometry changes that would affect the thread.
More specifically, in various implementations, the systems and techniques disclosed herein involve accurately representing a threaded feature of an object in a computer-aided design environment with an enhanced cosmetic thread (enhanced relative to prior cosmetic threads) without suffering significant impacts of creating faces typically associated with the geometry of a threaded feature. In this regard, for example, by generating representative curves for start and end locations and a pitch wire connecting the start and end locations and determining the resulting geometry of the curves trimmed by any geometry created later in the design process, the systems and techniques disclosed herein provide the user with an accurate representation of the thread feature in its final form without the overhead of having to generate the faces required for physical model geometry.
Moreover, in various implementations, the systems and techniques disclosed herein facilitate representing a threaded feature cosmetically during the design process and quickly and easily having a “real” physical threaded geometry when needed for marketing material or production needs for example. More specifically, by combining the cosmetic and physical thread commands into a single interface, the user can easily switch from one type to the other as needed. In a typical implementation, this has the benefit of a single source of thread specification and reduces the number of features required by half. Reducing the feature count of a component has the benefit of reducing the time required to compute and generate the geometry required for each feature.
In a typical implementation, having a single interface from which the user can choose to display a cosmetic thread (typically for performance reasons) or a physical thread (typically for marketing or production reasons) involves having a single feature (represented, e.g., by a common data structure) in the model's history (e.g., stored in computer-based memory) for the cosmetic thread and the physical thread, rather than two discreet features that need to be manually suppressed or unsuppressed. The benefits for the user are halving feature creation and suppression control requirements.
Moreover, the cosmetic threads allow the user to accurately represent a threaded feature without the negative impact of generating model geometry for the faces of the thread. The systems and techniques, in an embodiment, takes cosmetic threads beyond the state of the art and provides the user with an accurate representation of the final thread result taking into account all geometry created between the cosmetic thread feature and the final design. The cosmetic thread feature can be created at any point in the feature history including, e.g., after the hole or shaft it is applied to and, depending on settings, will be computed after all other feature geometry has been computed thus giving an accurate representation of the thread based on any subsequent intersecting geometry.
The ability to switch from cosmetic to physical threads, or vice versa, provides the user with the performance benefits of the cosmetic threads with the visual and functional presentation of the actual thread as needed.
Other features and advantages will be apparent from the description and drawings, and from the claims.
Like reference characters refer to like elements.
This document uses a variety of terminology to describe its inventive concepts. Unless otherwise indicated, the following terminology, and variations thereof, should be understood as having meanings that are consistent with what follows.
For example, in general, the phrase, “computer-aided design” refers to the use of computers (or workstations) to aid in the creation, modification, analysis, or optimization of a design. A “design” refers to a plan or specification (e.g., drawing), typically stored in computer-based memory, for an object or system, including construction details for that object or system. The Solidworks® or Catia® computer programs, available from Dassault Systèmes SolidWorks Corporation, the applicant of the current application, are examples of computer-aided design programs. Each of these computer programs can incorporate a design tool, known as xDesign™. As used herein, the phrase “computer-aided design” or “computer-aided design environment” should be construed broadly to include or involve any computer software, device, or system that incorporates or can incorporate the systems and/or techniques disclosed herein that relate, for example, to threads.
A “threaded feature” or a “thread” is a helical structure used to convert between rotational and linear movement or force. An “external thread,” for example, may be a ridge wrapped around a cylinder or cone in the form of a helix. An “internal thread,” for example, may be a helix-shaped ridge on an inner surface of a hole.
The helix of a thread can twist in two possible directions, known as the “thread direction” or “handedness.” Some threads are oriented so that the threaded item (e.g., a screw), when seen from a point of view on an axis of the object, through the center of the helix, moves away from the viewer when it is turned in a clockwise direction, and moves towards the viewer when it is turned counterclockwise. These are known as right-handed threads. Threads oriented in an opposite direction are known as left-handed threads. “Pitch” refers to a distance, along an axis of a threaded object, from the crest of one thread to the next.
The phrase, “cosmetic thread,” as used herein, refers to a schematic visual representation of a thread (e.g., in a hole or on a shaft) that represents the attributes of a threaded feature (e.g., shaft or hole) without having to show the real “physical threads” on a model in a computer-aided design environment. Traditionally, cosmetic threads may have been no more than a texture map used to represent the approximate look of a thread on a shaft or hole. Typically, cosmetic threads do not change the geometry of the model itself and, therefore, create minimal impact on system performance. In some implementations, traditionally, cosmetic threads are accompanied by callouts, with additional details, in a drawing.
The phrase “physical thread,” as used herein, refers to an actual, detailed visual representation of a physical, helical thread geometry on a threaded feature (e.g., shaft or hole). In a typical implementation, physical threads are required to facilitate three-dimensional (3D) printing of the threads, accurate mass property calculations, and finite element analysis involving the threads. Typically, representing a threaded feature in a model with a physical thread is much more demanding on system resources than representing the same threaded feature with a cosmetic thread. There are a variety of ways to create a physical thread. In a Solidworks® environment, for example, physical threads can be created using a thread tool based on a thread profile library.
A “blind” thread is a thread in hole that that is reamed, drilled, or milled to a specified depth without breaking through to the other side of an object or workpiece. In contrast, a through hole is a hole that is made to go completely through the material of an object.
The phrase “processor” or the like refers to any one or more computer-based processing devices. A computer-based processing device is a physical component that can perform computer functionalities by executing computer-readable instructions stored in memory.
The phrase “memory” or the like refers to any one or more computer-based memory devices. A computer-based memory device is a physical component that can store computer-readable instructions that, when executed by a processor, results in the processor performing associated computer functionalities.
Prior technologies exist for representing threaded features in computer-aided design.
For example, a cosmetic thread feature is available in the Solidworks® computer program.
As another example, a cosmetic thread feature exists in the CREO® computer program.
Yet another example is the cosmetic appearance feature in the Fusion 360® computer program.
The systems and techniques disclosed herein differ from the prior software in technical approach, execution, and output and, as such, overcome or at least significantly minimize various technical limitations of the prior system. As mentioned above, the systems and techniques disclosed provide a relatively simple, efficient way of informing viewers of the true nature of a threaded feature in an object within a computer-aided design environment. Moreover, in various implementations, the systems and techniques disclosed herein provide a single interface that enables easy and efficient switching between a representation of a threaded feature appropriate for generating marketing materials or the like and a threaded feature appropriate for three-dimensional (3D) printing applications, for example.
Other technical differences may exist between various prior technologies and the systems and techniques disclosed herein.
Referring again to
The processor 102 is configured to perform the various computer-based functionalities disclosed herein as well as other supporting functionalities not explicitly disclosed herein. Some such functionalities include enabling users to create thread designs, creating cosmetic threads to represent the thread designs, creating physical threads to represent the thread designs, and enabling users to easily and efficiently switch or toggle between different views that include cosmetic threads or physical threads. Typically, the processor 102, together with other computer components, performs these, and other, functionalities by executing computer-readable instructions stored on a computer-readable medium (e.g., in 104 or 106). In various implementations, some of these functionalities may be performed with reference to data stored in the computer-readable medium and/or received from some external source (e.g., an input/output (I/O) device via the I/O device interface 110 and/or from an external network via the network interface 108).
The computer 100 has volatile and non-volatile memory. More specifically, in a typical implementation, memory 104 provides a form of volatile storage storing computer-readable instructions that, when executed by the processor 102, cause the processor 102 to perform or facilitate some (or all) of the computer-based functionalities disclosed herein. Moreover, in a typical implementation, storage 106 provides a form of non-volatile memory storing computer-readable instructions, such as instructions to implement an operating system, configuration information, etc. The various system memory resources (e.g., 104, 106) may store data, as well.
In a typical implementation, the memory 104 stores the computer-readable instructions that, when executed by the processor 102, cause the processor 102 to execute functionalities that present to a user at the computer 100 a computer-aided design program, with the functionalities disclosed herein incorporated therein. An example of a computer-aided design program suitable for adapting to incorporate the functionalities disclosed herein is the xDesign™ design tool that may be incorporated into the Solidworks® or Catia® computer programs, for example, which are available from Dassault Systèmes SolidWorks Corporation, the applicant of the current application. The computer-aided design program, so adapted, would include one or more (or all) the thread design functionalities disclosed herein.
The network interface 108 is a component that enables the computer 100 to connect to any one or more of a variety of external computer-based communications networks, including, for example, local area networks (LANs), wide area networks (WANs), such as the Internet, or the like. In various implementations, the network interface 108 can be implemented in hardware, software, or a combination of hardware and software.
The input/output (I/O) device interface 110 is a component that enables the computer 100 to interface with any one or more input or output devices, such as a keyboard, mouse, display, microphone, speakers, printers, etc. In various implementations, the I/O device interface can be implemented in hardware, software, or a combination of hardware and software. In a typical implementation, the computer may include one or more I/O devices (e.g., a computer screen, keyboard, mouse, printer, touch screen device, etc.) connected to the I/O device interface 110. These I/O devices (not shown in
In an exemplary implementation, the computer 100 is connected to a display device (e.g., via the I/O device interface 110) and configured to present at the display device a visual representation of an interface to a product design environment, such as the one provided by and within the SolidWorks® computer program. The interface and its visual representation on the computer-based display device, in a typical implementation, provides the user with access to the thread design functionalities disclosed herein, and displays (e.g., on a display device coupled to the I/O device interface 110) a visual representation of a thread design (as a cosmetic thread and/or as a physical thread).
In some implementations, the computer 100 and its various components may be contained in a single housing (e.g., as in a personal laptop) or at a single workstation. In some implementations, the computer 100 and its various components may be distributed across multiple housings, perhaps in multiple locations on a network. Each component of the computer 100 may include multiple versions of that component, possibly working in concert, and those multiple versions may be in different physical locations and connected via a network. For example, the processor 102 in
In various implementations, the computer 100 may have additional elements not shown in
The illustrated computer network environment 300 has a server 302, and several client devices 304a, 304b, . . . 304n (or “clients”) coupled to one another via a communications network 306. The communications network 306 enables the server 302 and clients 304a, 304b, . . . 304n to communicate and interact with one another. In various implementations, each of the clients 304a, 304b, . . . 304n, and server 302 has the same or similar types of components as those shown in the computer 100 of
In some implementations, each client 304a, 304b, . . . 304n may be configured to perform any one or more (or all) of the thread design functionalities disclosed herein without requiring involvement of the server 302. In some implementations, the thread design functionalities disclosed herein may be distributed between the server 302 and any one or more of the clients 304a, 304b . . . 304n (e.g., the client where a human user is creating the threaded design or prompting the creation of or viewing a cosmetic thread and/or physical thread representation). In some implementations, a significant portion (or all) of the functionalities disclosed herein may be performed by the server 302 and the clients may simply provide a user interface for the user to access and leverage those functionalities. Various implementations may include one or more servers 302. In implementations that include more than one server, the servers 302 may collaborate with one another and/or with one or more of the clients 304a, 304b . . . 304n to provide or perform the functionalities.
The network environment 300, as represented in
The product design and development platform 301 in the illustrated network environment 300 has a plurality of software applications (App A, App B, App C, App D . . . App N) 324, and a database 326 that stores data relating to the software applications. In a typical implementation, each software application resides as a set of computer-readable instructions on a computer-readable medium (such as 104 or 106 in
The product design and development platform 301 can take on any one of a variety of configurations. In one exemplary implementation, the product design and development platform 301 may be based on the 3DEXPERIENCE® computer software platform, available from Dassault Systèmes, the applicant of the current application. In essence, the 3DEXPERIENCE® platform provides a collaborative environment that empowers businesses and users to innovate in highly effective and efficient manners. It provides organizations a holistic, real-time view of their business activity and ecosystem, connecting people, ideas, data, and solutions together in a single environment.
The applications 324 can include any one or more of a variety of different types of computer software applications. Some examples include applications that enable users, individually or collaboratively, to design and/or view parts or assemblies, including threaded parts, for example. Examples of such applications that may be deployed on Dassault's 3DEXPERIENCE® platform include xDesign™ computer software for use in computer-aided design, computer-aided engineering, computer-aided manufacturing, and/or visualization. In an exemplary implementation, software application (App A) in the illustrated implementation is just such a design program.
In the illustrated implementation, App A includes a thread design component 327 that supports and facilitates at least some (or all) of the functionalities disclosed herein that relate to thread design and/or viewing. The computer-based thread component 327 in the illustrated implementation is shown as being incorporated into App A directly. However, in some implementations, the computer-based thread component 327 may reside elsewhere (including in a separate physical component from App A or any of the illustrated applications 324). Regardless of where and how the thread component 327 is deployed, App A and, in some instances, any one or more of the applications 324 may be configured to access, utilize, and/or leverage its functionalities.
The network environment 300 is configured to present user-specific virtual workspaces (referred to as “user interfaces” 330a, 330b . . . 330n) at each of the user workstations 304a, 304b . . . 304n. Typically, each user interface 330a, 330b . . .330n produces a visual appearance on a display screen of the workstations that include at least a viewing/editing area where a user can view and/or edit a design, and a variety of user-accessible and user-selectable graphical control elements that when selected or interacted with give the user access to the various design and/or viewing options.
The database 326 may be built upon any one or more of a variety of different computer-based database platforms. In general terms, the database contains an organized collection of data (in this case, the data would be at least related to a design that includes a threaded feature) stored electronically (e.g., in 104 or 106 of
The user interfaces 330a, 330b . . .330n appear on the screens of the workstations 304a, 304b . . . 304n as virtual workspaces. In a typical implementation, each workspace displays design(s) for users to view and/or modify, as desired. In a typical implementation, if/when a user (at one of the user workstations) requests to access a design (e.g., stored in database 326), the network platform 301, in response to the user's request, returns a copy of the requested design to that user's workspace. The copy of the requested object that appears in the user interface is generally mutable. In other words, the user is able to modify the copy of the requested design that appears in the workspace. In some implementations, the user may utilize one or more of the system's applications to make any modifications. Once the user has made any desired modifications to the copy of the object that appears in the workspace, that user can publish (or save) the modified object back to the database 326. When this happens, a new version of the design is saved to the database 326. The new version includes the modifications that the user made in the workspace. Once the new version of the design is added to the database 326, typically, that new version is no longer mutable.
The various components of the product design and development platform 301 and other portions of the network environment 300 are coupled to one another in a manner that enables them to interact with one another and to provide users with access to, among other things, the functionalities related to thread design (including viewing cosmetic threads or physical threads) as disclosed herein.
The network environment 300 in
The flowchart in
One example of establishing thread definition data 662 is detailed in the flowchart of
The thread depth can be limited by the physical extent of the main body on which it is being created. Imagine a hole cut through a block. In a typical implementation, the thread in the virtual environment will not extend beyond the length of the block unless the user forces it to. A design tool (e.g., the xDesign™ tool) may be configured to support several methods of limiting the depth of a feature (e.g., a threaded feature). These can include, for example, Blind, Through
All, Up to Next, Up to Geometry, Up to Body, and Midplane. Up to Next generally creates the feature to the point of intersection with another model face. Up to Geometry generally creates the feature to the point of intersection with some model geometry that the user has selected. This could be a face, plane, vertex, edge, and so on. Up to Body generally creates the feature to the point of intersection with a selected body. A body can be thought of as something that is not connected to something else. E.g., two blocks separated by some distance with no connection between them. Midplane is akin to Blind in that it creates the feature to locations in two directions at the same time with a total combined depth of the midplane value. For example, a block extruded by Midplane with a depth of 2 inches typically will create geometry 1 inch in opposing directions away from the sketch plane for a total combined extrusion of 2 inches.
There are a variety of ways in which the thread configuration information can be set up (at 772). In one example, the computer 100 prompts or enables a human user to specify the thread configuration information. In this regard, the computer 100 may present, at its display, an onscreen menu (or thread property manager), an example of which is shown, and labeled as 992, in
Referring again to the flowchart of
There are a variety of ways in which the start edge for the thread may be specified. In one example, the thread property manager 992 includes a user-fillable field (see, e.g., the field labeled “start location” in thread property manager 992). In various implementations, the “start location” field may provide the user with a list of edges in the modeled object 994 that appears in the design field 996 of the user interface. In those implementations, the user may simply select one of the listed edges and the computer 100 treats the user selection as a designated start edge for the thread. In other implementations, the computer 100 enables the user to specify a start edge for the thread by pointing-and-clicking or something comparable to that. In a point-and-click approach, the user would navigate an onscreen pointer (e.g., by manipulating a mouse or tracking pad for the computer 100) to a location on the design field 996 that corresponds to the desired start edge for the thread and then left clicking or otherwise selecting the desired start edge. At that point, the “start location” field may populate with a notation that corresponds to the selected start edge. In the example shown in
In a typical implementation, the computer 100 stores the thread configuration information provided by the user (at 772) and the start edge provided by the user (at 774) in computer-based memory (e.g., 104 in
Returning again to
The process represented by the flowchart in
Next, in the illustrated implementation, the computer 100 (at 778) identifies an applicable thread standard. In some implementations, for newly created threads, the computer 100, by default, applies the best fit standard based on the calculated diameter of the threaded feature. If the threaded feature is a straight tapped hole, for example, the computer 100 may derive the thread standards from the hole standards. In a typical implementation, the computer 100 enables users to modify any standard that may have been identified by the computer 100 or specify other thread data.
Each thread standard generally has three key values: thread major diameter, pitch, and height. Thread minor diameter can be calculated (e.g., by processor 102) by subtracting two times the height from the major diameter. The best fit may be decided (e.g., again, by processor 102) by the following conditions: 1) the calculated diameter of the threaded feature (hole/shaft) has to be within the range of thread minor diameter and major diameter; and 2) if multiple standards exist for condition 1, for the cases of cutting material on a hole and adding material on a shaft, the standard producing the largest ratio of the difference between major diameter and calculated diameter over the height is identified (by processor 102) as the best fit standard; for the cases of adding material on a hole and cutting material on a shaft, the standard producing the largest ration of the difference between calculated diameter and minor diameter over the height is identified (by processor 102) as the best fit standard. Other approaches in this regard are possible as well.
Generally, a hole standard has the following components: 1) standard type: (e.g., ASME Inch, ASME Metric, DIN, ISO); 2) each standard type has a few hardware types (for straight tapped hole in ASME Inch, the hardware types are Bottoming Tapped Hole, Straight Pipe Tapped Hole, and Tapped Hole.), and 3) each hardware type has a list of sizing choices that determines the thread major diameter and pitch (so if a hole is straight tapped, its standard components (standard type, hardware type and sizing choice) are directly used by thread feature as its standard components).
Next, according to the illustrated implementation, the computer 100 (at 780) retrieves values of thread pitch and major diameter. The computer 100 may retrieve these values from tabulated data collections stored in computer-based memory (e.g., 104) based on the applicable thread standard (identified at 778) or from customized thread data provided by a human user if a standard is not being wholly relied upon.
Next, in the illustrated implementation, the computer 100 (at 782) calculates the height and minor diameter of the threaded feature. In a typical implementation, the height and minor diameter of the threaded feature can be calculated based on thread pitch and major diameter, which are thread characteristics that may be specified in the applicable thread standard or other thread data provided by the human user.
Next, according to the illustrated implementation, if (at 784) the thread length is limited by certain geometry, as established at 662, then the computer 100 (at 786) calculates the thread length. In a typical implementation, algorithm(s) are applied (e.g., by processor 102) to find the distance between the start location of the thread and the geometry specified as the limit. The calculated distance is designated (e.g., in computer memory) and considered by the computer system as the thread length. The algorithm(s) may involve calculating a difference between two points in a coordinate system that correspond to ends of the thread.
The process then advances to
According to the process represented by the flowchart of
If the computer (at 788) determines that the threaded feature is to be represented by a cosmetic thread, then the computer 100 (at 790) constructs a helical curve for the thread and start and end circles. In some implementations, the computer 100 defines the start circle as having a diameter that corresponds with the diameter of the threaded feature (from 776) and located at the start edge (specified at 774). In some implementations (e.g., where the threads are not tapered), the computer 100 may define the end circle as having the same diameter as the start circle. Moreover, in one example, the computer 100 locates the end circle at a distance from the start edge, along a neighboring surface of the start edge, which corresponds to the thread length (e.g., calculated at 786). Additionally, in one example, the computer defines the helical curve based on thread height (from 782) and pitch (from 780) and as extending between the start and end circles. In a typical implementation, the computer 100 is configured to utilize the constructed helical curve and start and end circles to produce preview and final result calculations of the threaded feature, for example.
Next, the computer 100 (at 792) determines if the threaded feature is to be created by adding material or removing material. In a typical implementation, the computer 100 makes this determination by referencing the material type (add material or cut material) established as thread definition data (at 662) and stored in computer-based memory (e.g., 104). If the computer 100 (at 792) determines that the threaded feature is to be created by adding material, then the computer 100 (at 794) enlarges the solid model geometry by thickening over the cylindrical surface to be threaded. There are a number of possible ways in which the computer 100 thickens and determines how much to thicken the solid model geometry. In one example, thickening is done by utilizing an existing CATIA Convergence Geometric Modeler (CGM) operator. Basically, in this example, thickening is performed by offsetting the specified surfaces a certain distance and extending the neighboring surfaces to maintain the manifold shape. The actual thickening value is decided by the difference between thread wire radius and threaded feature radius plus a small value that is equal to e.g., 5% of the thread wire radius. According to one example, the computer determines how much to thicken the solid geometry by comparing a diameter of the feature to be threaded with an outer diameter of threads (from 780) and then thickening by an amount that would correspond to the outer diameter of the threads.
Then, the computer 100 (at 796) trims the helical curve (constructed at 790) to conform to the enlarged geometry of the model. In an exemplary implementation, the computer 100 trims the helical curve in accordance with the diameter of the enlarged threaded feature.
Otherwise, if the computer 100 (at 792) determines that the threaded feature is to be created by removing or cutting material, then the computer 100 skips step 794 and proceeds to trim the helical curve (constructed at 790) to confirm to the solid model geometry, without thickening.
Next, in the illustrated flowchart, the computer (at 798) calculates (identified) the boundaries of the trimmed helical curve. In a typical implementation, the computer 100 performs this calculation by intersecting a cylindrical envelope of the helical curve with the neighboring faces of the threaded cylindrical surface. The intersections of the helical curve with the neighboring faces of the threaded cylindrical surface in this section would be the boundaries of the trimmed helical curve. In one exemplary implementation an intersecting algorithm may be performed (e.g., by processor 102) between the cylindrical surface and each of the neighboring faces. This face-to-face intersection may be implemented in this example by using an existing CATIA CGM operator
If the computer 100 (at 788) determines that the threaded feature is to be represented by a physical thread, for example, then the computer 100 (at 791) constructs the thread profile. There are a variety of ways in which the computer 100 may perform this task. In one example, the computer 100 constructs the thread profile based on the data established, calculated, or specified throughout the various steps set forth in
Next, according to the illustrated implementation, the computer 100 (at 793) constructs a sweeping spine (e.g., a helical curve and additional curve at both ends of the helical curve for tapering). If there is no taper, there will be no additional curve at the end of helical curve. This extra curve is added to the sweeping spine so that the thread end can gradually tapper down.
Next, in the illustrated flowchart, the computer 100 (at 795) creates a thread tool body by sweeping the thread profile along the spine. The phrase “tool body” as used here is a term for the body that may be involved in Boolean operations, for example, such as subtracting and union. Sweeping, in an exemplary implementation, may be performed (e.g., by processor 102) utilizing a CATIA CGM operator. Basically, the solid is created by sweeping a profile along a path (a.k.a. spine).
The computer 100 then (at 797) determines if the threaded feature is to be created by adding material or removing material. The computer 100 may make this determination by referencing the material type (add material or cut material) established as thread definition data (at 662) and stored in computer-based memory (e.g., 104).
If the computer 100 (at 797) determines that the threaded feature is to be created by adding material, then the computer 100 (at 799) enlarges the solid model geometry (by thickening) to subsequently trim the thread tool body and then unions (incorporates) the trimmed thread tool body with the current solid model geometry (at 745). Otherwise, if the computer 100 (at 792) determines that the threaded feature is to be created by removing or cutting material, for example, then the computer 100 (at 800) subtracts the thread tool body from the current solid model geometry and then unions the result with the current solid model geometry (at 745).
Next (after step 798, 799 or 800), the process advances to 668 in
The computer 100 (at 670) enables switching, easily and efficiently, between a first version of the modelled object with the cosmetic thread representing a threaded feature on the object, or a second version of the modelled object with the physical thread representing the threaded feature on the object. This ability to switch also is represented in
The data to support the functionalities disclosed herein can be structurally configured in any one of a variety of different ways. In one example, the data structures (common, decorative, 5 and physical) may be configured in accordance with the following.
10
In view of the foregoing, it can be appreciated that, in some implementations, the workflow at the user interface would include: 1) Invoking thread feature functionality at the user interface, 2) specifying certain thread definition (or configuration) details including, for example, material type (e.g., cut material or add material), geometry type (e.g., cosmetic thread or physical thread), direction type (e.g., left-handed or right-handed), and/or length option (e.g., blind or limited by a specified geometry). Next, the user selects a circular edge associated with the threaded feature (a hole feature or a circular cut feature) as the start edge for threading. The user may specify additional settings such as display options, modify standards information and/or customize values of pitch and/or diameter, for example. The computer 100 is generally configured to display the geometry in a preview mode. The ability to switch between cosmetic and physical thread views is present in the preview mode and the geometry can be updated in the preview mode. The user can confirm settings to create a final geometry for the threaded feature.
Moreover, in view of the foregoing discussion, it can be appreciated that, in some implementations, after the start edge and the configurations are specified, the following data processing may be performed by the computer 100 to support thread geometry construction: 1) calculating a diameter of the threaded feature, and determining a thread start location and direction, 2) calculating the best-fit standard or deriving the thread standard if the threaded feature is a straight tapped hole feature, 3) retrieving the values of thread pitch and thread diameter from the standard tables or directly use customized ones (provided by a user) if the standards are not used, and 4) calculating the thread length if the length is limited by a specified geometry.
Thread geometry construction comes next in a typical implementation. Based on the definition and processed data, thread geometry can be constructed in two modes: preview and true result and may depend on the thread geometry type (cosmetic or physical).
With respect to cosmetic thread geometry construction, unlike some regular design features such as extrusions and fillets that are history based, cosmetic features are global features, which means that, ultimately, the geometry of cosmetic thread must reflect the final model geometry. Therefore, in a typical implementation, the actual geometry of a cosmetic thread is constructed after the model geometry is finalized. The following, which references
First, the computer 100 constructs helical curves 880 and start and end circle curves 882 for geometry preview during feature creation (see, e.g., 790 in
In a typical implementation, the helical curves 880 can be turned off in preview mode. Typically, this would leave the end circle curves 882 intact.
To obtain the true geometry of a cosmetic thread, in a typical implementation, the helical curves (e.g., 880 in
To reflect the boundaries (see, e.g., 798 in
In various implementations, the computer 100 is configured to display images of modelled objects with cosmetic threads in any one of a variety of different ways (see, e.g., 668 in
For example, in some implementations, the computer 100 is configured to display an image of the modelled object with the trimmed helical curves but without the end curves and boundaries, and alternatively to display an image of the modelled object with the trimmed end curves and boundaries, but without the helical curves.
In some implementations, the computer 100 is configured to display an image of a modelled object with an untrimmed version of the helical curves, for example. This may result from the user, for example, turning off the computer's trimming functionality. In some instances, a user may wish to turn off the computer's trimming functionality due to the relatively large computational burden involved in the trimming and related processes involving intersections, etc.
As discussed above, the computer 100 is also configured to create physical thread geometry constructions. In a typical implementation, a physical thread is a regular history-based feature, and its final geometry is calculated at the time of its creation or editing. In some implementations, the physical thread is obtained by booleaning its original/trimmed tool body with the current final model geometry. In a typical implementation, booleaning may include, for example, either subtracting an original tool body from the current final model geometry for a cut material option or merging (union) the trimmed tool body with the current final model geometry for an add material option.
In an exemplary embodiment, the computer 100 performs the following steps in constructing the thread geometry in preview mode and/or true result mode: 1) constructing a thread profile (see, e.g., 791 in
For a cut-material thread, the computer 100 may calculate the true result by subtracting the tool body from the current model geometry (see, e.g., 800 in
In various implementations, the computer 100 is configured to display images of modelled objects with true results (physical threads) in any one of a variety of different ways (see, e.g., 668 in
In a typical implementation, the computer 100 may also (or alternatively) be configured to present a preview of the true results (e.g., during feature creation). This, however, may not always be advisable, especially when constant user interface (UI) changes (such as length changes from the dragging of an onscreen manipulator) are involved.
The computer 100, in various implementations, is configured to facilitate switching between cosmetic threads and physical threads.
Thus, in a typical implementation, a user can create either a cosmetic thread or a physical thread first and then can switch to the other type during feature creation or feature editing (see, e.g., 670 in
In a typical implementation, additional data unique to each thread type (cosmetic and physical) may be directly held by either the cosmetic thread or the physical thread. This additional data may include, for example, data identified or created in constructing the cosmetic and physical thread geometries (at 666).
In a typical implementation, a user request to switch between thread types may cause the computer 100 to create one of the types of the threads (e.g., the one requested) and to delete the other type of thread (e.g., the one the user is asking to move away from). If, for example, the user requests switching from viewing an image of a modelled object that includes a cosmetic thread to viewing instead an image of the modelled object that includes a physical thread, then the computer 100 responds by creating the image of the modelled object that includes the cosmetic thread and deleting the image of the modelled object that includes the physical thread. The user may then utilize the image of the modelled object that includes the physical thread in the computer to 3D print a real-world version of the modelled object.
When the computer 100 switches between the cosmetic thread and the physical thread, the newly created thread simply takes over the common data before the to-be-switched thread is deleted, which prevents the unnecessary data recreation and/or data transferring. In a typical implementation, an initial switch from a physical thread to a cosmetic thread may result in the computer 100 removing geometries from the physical thread, whereas an initial switch in the other direction may result in the computer 100 creating new geometries for the physical thread. The removing and adding of geometries in the model typically follows history-based update handling, thus the reference update for downstream features will be handled systematically. History-based modeling is a de facto modeling technique in certain major CAD packages. Here we use this term to mean that, in an exemplary implementation, a physical thread behaves exactly as traditional modeling features that follow history-based modeling. As a cosmetic thread is a global feature (e.g., holding a wire body for display), it does not participate in history-based updates in the model geometry, but its final result will be always calculated based on the finalized model geometry from any modeling operations that triggers a model change.
The screenshot of FIG, 9A, for example, has a design field 996, a design manager 997 of user-selectable options, and a thread property manager 992 that prompts or enables the user to specify the thread confirmation information. The design manager 997 in the illustrated implementation sequentially lists, from top to bottom, the features in the order the user created them. The illustrated thread property manager 992 includes user-fillable text fields, and user-selectable options and dropdown menus to prompt or enable the user to provide the thread configuration information. The information that the thread property manager 992 in the illustrated implementation enables a user to specify includes thread type (cut vs. add, and cosmetic vs. physical), thread start location, offset, depth, distance, standard, thread type, size, and other thread options (e.g., quick preview, taper ends, and handedness), and display options. A modelled object (component) 994 appears in the design field 996. Notably, the cosmetic and physical selectable options are visible on one common screen, enabling the user to easily switch or toggle between a view containing a cosmetic thread and a view containing a physical thread.
In
In the
In
In
In
In
In
In
In
In
In
A number of embodiments of the invention have been described. Nevertheless, it will be understood that various modifications may be made without departing from the spirit and scope of the invention.
For example, certain implementations of the cosmetic thread functionalities, such as those disclosed explicitly herein, work on cylindrical holes and shafts. However, these techniques can be expanded to include other geometries such as conical holes/shafts for things like hydraulic fittings. Theoretically, the system and functionalities disclosed herein may be able to create threads (cosmetic and physical) on any shape using various modeling techniques.
Moreover, the systems and techniques disclosed herein (including those related to the creation and display of cosmetic threads, alone or as an alternative to non-cosmetic threads) are not limited to creation or display of actual threads (in a virtual environment), but may be used to represent other physical components, such as an Archimedes' screw or a ramp in a vibratory bowl feeder, etc. (in a virtual environment). Moreover, the threads or similar structures can be created on non-circular/cylindrical geometries. Indeed, threads (including thread-like features) can be created on virtually any shape, as tapered threads, threads on a square body, self-locking nuts, triangular screws, etc. Additionally, threads can be created in a non-continuous helix. A case like this is the threads on the opening of a plastic soda bottle, for example.
The phrase computer-aided design or computer-aided design environment should be construed broadly to include or involve any computer-based systems or techniques for designing, engineering, simulating, or viewing designs with one or more computers or computer-based components.
In various implementations, certain computer components disclosed herein (e.g., applications, design tools, etc.) can be implemented by one or more computer-based processors (referred to herein as processor) executing computer-readable instructions stored on non-transitory computer-readable medium to perform the associated computer-based functionalities. The one or more computer-based processors can be virtually any kind of computer-based processors and can be contained in one housing or distributed at different locations, and the non-transitory computer-readable medium can be or include any one or more of a variety of different computer-based hardware memory/storage devices either contained in one housing or distributed at different locations.
Certain functionalities are described herein as being accessible or activated by a user selecting an onscreen button or the like. This should be construed broadly to include any kind of visible, user-selectable element or other user interactive element.
The systems and techniques disclosed herein are not limited to product design using CAD software specifically in mechanical design. Another area where these systems and techniques might be useful is video game design by generating representative curves (or skeletons) of objects that can then be used to build geometry on top of The intersection of the curves with existing and downstream geometry and the ability to update those curves after all other geometry has been created could be beneficial to determining and updating geometry based on collision detection in a gaming environment, as an example.
The systems and techniques disclosed herein can be implemented in a number of different ways. In one exemplary implementation, the systems and techniques disclosed herein may be incorporated into the xDesign™ computer program available from Dassault Systèmes, the applicant of the current application. In various implementations, the systems and techniques can be deployed otherwise.
It should be understood that the example embodiments described herein may be implemented in many different ways. In some instances, the various methods and machines described herein may each be implemented by a physical, virtual, or hybrid general purpose computer, such as a computer system, or a computer network environment, such as those described herein. The computer/system may be transformed into the machines that execute the methods described herein, for example, by loading software instructions into either memory or non-volatile storage for execution by the CPU. One of ordinary skill in the art should understand that the computer/system and its various components may be configured to carry out any embodiments or combination of embodiments of the present invention described herein. Further, the system may implement the various embodiments described herein utilizing any combination of hardware, software, and firmware modules operatively coupled, internally, or externally, to or incorporated into the computer/system.
Various aspects of the subject matter disclosed herein can be implemented in digital electronic circuitry, or in computer-based software, firmware, or hardware, including the structures disclosed in this specification and/or their structural equivalents, and/or in combinations thereof. In some embodiments, the subject matter disclosed herein can be implemented in one or more computer programs, that is, one or more modules of computer program instructions, encoded on computer storage medium for execution by, or to control the operation of, one or more data processing apparatuses (e.g., processors). Alternatively, or additionally, the program instructions can be encoded on an artificially generated propagated signal, for example, a machine-generated electrical, optical, or electromagnetic signal that is generated to encode information for transmission to suitable receiver apparatus for execution by a data processing apparatus. A computer storage medium can be, or can be included within, a computer-readable storage device, a computer-readable storage substrate, a random or serial access memory array or device, or a combination thereof. While a computer storage medium should not be considered to be solely a propagated signal, a computer storage medium may be a source or destination of computer program instructions encoded in an artificially generated propagated signal. The computer storage medium can also be, or be included in, one or more separate physical components or media, for example, multiple CDs, computer disks, and/or other storage devices.
Certain operations described in this specification (e.g., aspects of those represented in
While this specification contains many specific implementation details, these should not be construed as limitations on the scope of any inventions or of what may be claimed, but rather as descriptions of features specific to particular embodiments of particular inventions. Certain features that are described in this specification in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable subcombination. Moreover, although features may be described above as acting in certain combinations and even initially claimed as such, one or more features from a claimed combination can in some cases be excised from the combination, and the claimed combination may be directed to a subcombination or variation of a subcombination.
Similarly, while operations may be described herein as occurring in a particular order or manner, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order, or that all illustrated operations be performed, to achieve desirable results. In certain circumstances, multitasking and parallel processing may be advantageous. Moreover, the separation of various system components in the embodiments described above should not be understood as requiring such separation in all embodiments, and it should be understood that the described program components and systems can generally be integrated together in a single software product or packaged into multiple software products.
The systems and techniques disclosed herein may be utilized in connection with producing, reviewing, analyzing, and otherwise considering a design of a real-world object that includes, e.g., a physical structure having a threaded feature. Typically, the processes disclosed herein may be utilized to produce marketing materials and the like to sell, discuss, attract investments on, etc. product development and/or commercialization efforts. The design and review process, once completed using one or more techniques disclosed herein, may be followed by manufacturing a real-world version of the designed object (that includes, e.g., the threaded feature) based on the final design that may have been developed using one or more of the techniques disclosed herein. The final, manufactured real world version of the designed object would be a real-world physical thing (e.g., a machined part or component that includes real-world threads).
The systems and techniques disclosed herein also enable a computer or computer system to quickly and efficiently (from a resource utilization perspective) produce different types of visual representations of a particular feature (e.g., a thread on an object) in a virtual environment, where each of the different types of visual representations is better suited than the other for a particular type of task—e.g., understanding that the thread exists vs. seeing and being able to access precise design details associated with the thread in the visual representation. The systems and techniques also enable the computer or computer system to quickly switch between such alternative views on one a single interface that enables the user to choose to display, for example, a cosmetic thread or a physical thread, based on a single feature in the model's history rather than two discreet features that would need to be manually suppressed or unsuppressed to toggle between them.
Other implementations are within the scope of the claims.
This application claims the benefit of priority to U.S. Provisional Patent Application No. 63,281,834, entitled THREE-DIMENSIONAL (3D) MODELING OF A THREADED FEATURE USING COMPUTER-AIDED DESIGN, which was filed on Nov. 22, 2021. The disclosure of the prior application is incorporated by reference herein in its entirety.
| Number | Date | Country | |
|---|---|---|---|
| 63281834 | Nov 2021 | US |
