The present disclosure relates to the field of computer aided design systems. More specifically, the present disclosure relates to computer aided design systems, computer aided design applications, and associated programming interfaces and scripting languages.
Computer aided design (CAD) relies on the processors and memory circuits (both working memory and storage memory) of computers, sometimes called computer workstations. CAD permits users to create, analyze, modify, and optimize mechanical and electrical designs before physically implementing the designs. The designs may be based on compilations of modeled objects (e.g., goods and materials) comprised of one or more component parts, subassemblies, and assemblies. One or more mathematical formulae may mathematically represent each modeled object. The formulae account for myriads of variables that together define the modeled object. For example, a steel beam model may specify its shape (e.g., I-beam, T-beam), width, length, height, alloy type, hardness, tensile strength, elongation, fatigue strength, corrosion plasticity, melting point, etc. A model of an electrical capacitor may specify its shape (e.g., chip or with leads), width, length, height, form factor, capacitance, tolerance, temperature range, series resonance frequency, parasitic inductance, etc. Formulas used to model objects with precision may require tens of variables to achieve realistic results for analysis and optimization.
Additionally, while component objects may be created and analyzed individually, it may be necessary for CAD systems to combine the component objects to form subassemblies and assemblies to obtain the full benefit of using a CAD system. Therefore, CAD systems may have an ability to model the subassemblies, to account for interactions between component objects, and may have an ability to model assemblies, to account for interactions between subassemblies as well as interactions between modeled objects. There may be significant demands made on the processors and memory circuits of the computers that employ CAD.
Examples described herein include various systems, devices, methods, and servers including but not limited to a system implementing a computer aided design application and an associated computer aided design application programming interface and scripting language, a client device implementing a computer aided design application programming interface and scripting language both associated with a computer aided design application, a first method, operational at a client device, implementing a computer aided design application programming interface and scripting language both associated with a computer aided design application, a server implementing computer aided design application and an associated computer aided design application programming interface and scripting language, and a second method, operational at a server, implementing a computer aided design application and an associated computer aided design application programming interface and scripting language.
In the following description, specific details are given to provide a thorough understanding of the described implementations. However, it will be understood by one of ordinary skill in the art that the implementations may be practiced without these specific details. For example, circuits may be shown in block diagrams or in a simplified representation to avoid obscuring the implementations in unnecessary detail. In other instances, well-known circuits, structures, and techniques may be shown in detail so as to not to obscure the implementations.
Also depicted in
As shown in
At 202, a project request is made to a systems engineering 204 entity. The systems engineering entity 204 may utilize a systems CAD application (not shown) to develop requirements 206 according to the parameters provided to the systems engineering 204 entity with the project request. The requirements 206 may be formalized in various documents, drawings, spreadsheets, etc., all generally prepared by the systems engineering entity 204. The systems engineering entity 204 may also create subsystems of requirements 208, which may be developed from the earlier mentioned requirements 206. The requirements 206 and subsystems of requirements 208 may be forwarded to a design entity 210.
The design entity 210 may create CAD models and prototype items 212 (e.g., mechanical, electrical, software, data, etc.) using a design CAD application (not shown). At 214, the design entity 210 may realize that one or more of its designed CAD models and prototype items 212 may be unable to converge (for example, due to unrealistic requirements). Accordingly, the design entity 210 may declare a failure 216. Declaring the failure 216 may energize a bureaucracy to handle the failure at block 218. Once the failure is handled, the workflow 200 may be sent to block 220 for failure analysis. Once the failure analysis is completed, at block 222, the failure analysis may be combined with a request for a review.
Based on the results of the review at block 222, an order may be given to the design entity 210 to change the design according to accommodate the failed analysis at block 224. Alternatively, or additionally, based on the results of the review at block 222, an order may be given to the systems engineering entity 204 to change the original system and requirements for the design at block 226. If the order is given to the systems engineering entity 204, the workflow 200 may return to creating subsystems of requirements 208. After that, the systems engineering entity 204 may provide new requirements 208 to the design entity 210. If the order was given to the design entity 210 to change the design to accommodate the failed analysis at block 224, the design entity 210 may again create CAD models and prototype items 212. The workflow 200 may loop again as many times as are needed to overcome the failure 216.
Once the designs converge 214, the design entity 210 may forward the designs to the analysis entity 228. The analysis entity 228 may utilize an analysis CAD application (not shown) and, at block 230, may run simulations to predict success (e.g., any one or more of electrical, thermal, structural, design for maintainability (DFM), etc. simulations). The simulations run at block 230 may result in a failure 232, which may again energize the bureaucracy at block 218 to handle the failure. Alternatively, the simulations run at block 230 may be simulations used for failure analysis at block 220, simulations combined with failure analysis, and the request for review at block 222, or both. In all three circumstances, the workflow 200 would return to block 224, block 226, or both and cycle through all of the preceding workflow 200 processes as many times as are needed to overcome any failures (e.g., failure 216, failure 232).
Once the analysis is completed, the analysis entity 228 may forward the designs to the build/manufacture entity 234. The build/manufacture entity 234 may utilize build/manufacture CAD application (not shown) and, at block 236, may create a bill of material and drawings that manufacturers can utilize and understand. After that, at block 238, materials may be purchased for the manufacture and assembly of parts. However, at block 240, tolerance issues, previously missed defects, manufacturing error, human error, or any combination thereof may conspire to cause another failure 242. In such a circumstance, the workflow 200 would return to block 218 and, starting at block 218, cycle through all of the preceding workflow 200 processes as many times as are needed to overcome any failures (e.g., failure 216, failure 232, failure 242).
Once the build/manufacture entity 234 has completed its tasks successfully, the build/manufacture entity 234 may pass responsibility for the project to the testing entity 244. The testing entity 244 may utilize a testing CAD application (not shown) and, at block 246, may test the product to verify that the product meets the original or revised requirements (as the case may be). However, at block 246, testing may reveal that the product does not meet the requirements, and still another failure 248 might be declared. In such a circumstance, the workflow 200 would return to block 218 and, starting at block 218, cycle through all of the preceding workflow 200 processes as many times as are needed to overcome any failures (e.g., failure 216, failure 232, failure 242, failure 248), until, finally, at block 250, the project could be successfully completed and the product could be built.
The processes described above in connection with the workflow 200 of
With reference to a new scripting language for use with the CAD application and/or CAD API, in some examples, the scripts generated using the scripting language described herein may not be accessed in an automated manner. For example, and without limitation, according to one aspect, they cannot be called by other scripts, called in a command line, deployed to the cloud, and run (executed) there (e.g., run in remote servers, etc.).
The CAD application and associated CAD API described herein may utilize a file type that may be a new file type for CAD. As used herein, the term “file type” may be used to refer to the functional and/or operational structure of a file (e.g., how the file is built/constructed/used) and should not be confused with the term “file extension” which relates to how the file is named. Files that store data using the file type for CAD may utilize digital certificates and may include an edit history. Files that store data using the file type for CAD may include a capability that permits the file to be generated with a last allowable access date that may be a date on which access to the file automatically expires or the date on which access to the file may be revoked.
In some examples, files that store data using the file type for CAD may be stored as a non-fungible token (NFT) on a blockchain.
In some examples, files that store data using the file type for CAD may include smart contracts on blockchain (e.g., licensing, resale agreements, profit-sharing, etc.). As used herein, smart contracts on blockchain are programs stored on a blockchain that runs when one or more predetermined conditions are met. A smart contract may be used to automate the execution of an agreement so that all participants can be immediately sure of the outcome without any intermediary's involvement or time loss. Smart contracts may also be used to automate a workflow, triggering a following action when predefined conditions are met.
In some examples, files that store data using the file type for CAD may be accessed programmatically as an object. As used herein, an “object” may be a variable, a data structure, a function, or a method, and as such, it can be represented in a memory and referenced with an identifier. For example, one interaction (e.g., an object call) with a file of the described file type may be: partFile.mass( ) where partFile is the file name and mass is a function call on the file named partFile. Another example may be an interaction using the form partFile.mass, where partFile is the file name and mass is a property of the file named partFile. The files themselves, as objects, may be found within a given project according to a predetermined “foldering” structure. The predetermined foldering structure may be configured so that no file searching would need to be resolved and no name-overlapping would need to be resolved. As shown in the preceding two examples, the file being called as an object could be implemented in various manners. The preceding examples are provided for discussion and are non-limiting.
In some examples, the file type itself may define whether and which user/entity may view/interact with a file and/or whether and which a machine may access/print/manufacture a file. For example, files that store data using the file type for CAD may programmatically define which user/entity or machine may access a given file. For example, the file type may implicitly indicate that a first brand of a 3D printer may print the file, and a second brand of a 3D printer may not print the file. Or, as another example, the file type may implicitly indicate that a given machine shop (a first entity) may open a file, while a second machine shop (a different entity, a second entity) may not open a file.
In some examples, files that store data using the file type for CAD may allow programmatic access to CAD features (coordinate systems, sketches, solids, surfaces, edges, etc.). According to some examples, files that store data using the file type for CAD may allow programmatic access to CAD features in any programming language and on any operating system.
In general, the CAD application and associated CAD API described herein may allow code creation through user interaction in a graphic user interface (GUI). Conversely, the CAD application and associated CAD API described herein may allow code creation through GUI interaction with a user. In other words, the GUI may make suggestions to the user of ways to alter a model to obtain a desired result. For example, direct interaction examples may include filling in a given component of something. The filling in may be toggled in the script as a user interface (UI) interaction or a typing interaction or in the GUI as a direct point and click interaction. By way of example, say a user is trying to place an item such as a vertex or cube or line in a 3D coordinate axis system (x,y,z), or in a 2D coordinate axis system (x,y). Instead of manually typing (entering) those values, the user might move to the location and identify it with a point-and-click; thereafter, the CAD application may automatically update the values in the code. The opposite may also be true. For example, the user may type in the values, and those values may be automatically updated in the graphics representation of the values. Furthermore, the user may be able to choose how the user and the CAD application interact, for example, coding to create what the user wants, using point-and-click and have the code be automatically generated by the user's interaction with a GUI, or coding and using point-and-click, as well as choosing whether to have sections automatically generate aspects or manually generate aspects as the user sees fit.
The CAD application 416 and associated CAD API (e.g., first endpoint of CAD API 408A, second endpoint of CAD API 408B, collectively referred to hereinafter as “CAD API 408”) described herein may be designed so that more complex software need not be built on top of it. More specifically, at least a portion of the CAD application 416 described herein may be configured as a common core 430, below a plurality of sub-applications (e.g., a first sub-application 432, a second sub-application 434, . . . , an nth sub-application 436, where n is a positive integer) (collectively referred to as the CAD application 416). The plurality of sub-applications may relate to respective features of the CAD application 416, such as, but not limited to, design, modeling, analysis, optimization, testing, documentation, and manufacturing, etc. Due to the comprehensive nature of the CAD application 416, there may be no need to build external programs on the CAD application 416.
In one sense, the common core 430 may form a foundation on which rests the plurality of sub-applications that may implement the various features of the CAD application 416. The plurality of sub-applications may interact with and/or utilize native functions of the common core 430. The plurality of sub-applications may interact with each other directly or indirectly (e.g., via the common core 430) without having to call external applications (e.g., that may not interface with the common core 430). In its foundational sense, the common core 430 may be referred to as a kernel or as an engine. However, the common core 430 of the CAD application 416 may be distinct from an operating system kernel, which, as known to those of skill in the art, is a computer program at the core of a computer's operating system. The operating system kernel may have ultimate privileges, and it may be the first thing that boots when a computer processing system is turned on. In contrast, the common core 430 (kernel or engine) of the CAD application 416 described herein may lie above the operating system kernel (not shown). There may not be any intermediate programs between the operating system kernel and the common core 430 of the CAD application 416.
In its foundational position, the common core 430 of the CAD application 416 may, for example and without limitation, perform server side operations that may include basic mathematic operations (e.g., addition, subtraction, multiplication, division), to higher level operations (e.g., solutions to algebraic, geometric, and trigonometric functions), to even higher level operations (e.g., calculus, partial differential equations, differential equations, Fourier transforms and inverse transforms, Laplace transforms and inverse transforms, thermodynamics, static and dynamic mechanical, structural, materials science, environmental, and electrical engineering functions), and logic operations (e.g., Boolean logic) that may facilitate the operation of the sub-applications of the CAD application 416. Furthermore, and for exemplary and non-limiting purposes, the common core 430 of the CAD application may perform services related to rendering and handling of graphic processing unit (GPU) multi-threading, etc. Because the common core 430 of the CAD application 416 may perform the operations and functions for all of the various features and sub-applications of the CAD application 416, the CAD application 416 may not need to call on external programs that are not interfaced with the common core in order to implement the various features offered by the CAD application 416. Use of the common core 430 may therefore reduce redundancy by, for example, facilitating the use of a shared common resource (i.e., the common core 430). Accordingly, communications, speed, and energy (e.g., electrical power) burdens placed on processors implementing known CAD systems (that may rely on a plurality of applications (e.g., external applications) that do not share a common core) may be alleviated by the use of the CAD application 416 described herein.
Additionally, the CAD application 416 and associated CAD API 408 may be designed for future improvements to its logic and intelligence, which may be added to the CAD application 416 and/or CAD API 408 as time goes on. Because each sub-application may utilize the common core 430, some of the future improvements may only need to be pushed to, or made to, the common core 430. This may reduce redundancy and increase precision because one change to the common core may be used to implement the future improvements to the CAD application 416 as a whole (instead of implementing the future improvements by pushing changes to each of the plurality of sub-applications). Of course, nothing herein is intended to limit the implementation of any future change to the CAD application 416 or CAD API 408 to a change to the common core 430 alone.
The CAD application 416 may operate on objects as well as subassemblies and assemblies comprised of those objects. The objects may range from basic building blocks of two-dimensional and three-dimensional shapes to shapes that are themselves made of multiple intricate or detailed shapes (e.g., complex shapes). In addition to shape, each object may include parametric data that, for example, quantify the qualities of the object and how the object reacts to forces and the environment (e.g., each object may be associated with a host of parametric data quantifying aspects of the object for purposes of, at least, design, modeling, analysis, optimization, testing, documentation, and manufacturing).
According to some aspects, the CAD API 408 described herein may be described as an API-first developmental item. In one example, the CAD API 408 need not be built on top of a graphical user interface program. It may be designed to interface with other applications, including but not limited to: word processing, spreadsheet, circuit simulation, thermal analysis, continuous integration, engineering analysis, computer aided manufacturing, physical inspection software, robot path planning, enterprise resource planning, manufacturing resource planning, product lifecycle management, and/or supply chain optimization. Furthermore, other applications may wrap the CAD API described herein into other use cases, such as, but not limited to, program management, financial planning, billing, procurement, and/or systems engineering, etc.
In some examples, the CAD API 408 may be built as a representational state transfer (REST) API (also referred to as a RESTful API). When built as a REST API, the CAD API 408 allows any programming language (e.g., but not limited to, Python, JavaScript, Bash, Rust, Ruby, Golang, C, C++, COBOL), any operating system (e.g., but not limited to, MacOS, iOS, Windows, Windows Phone, Windows Embedded, Microsoft Phone, Linux Distributions), etc. to call its commands. Commands may include, but are not limited to, DELETE, PUT, GET, POST, PATCH, and/or CUSTOM Parameters. A REST API provides access to data by using a uniform and predefined set of operations. REST APIs may be based on uniform resource language (URLs) and the hypertext transfer protocol (HTTP). REST is not a protocol or standard. Instead, REST defines a set of six architectural constraints that are summarized as follows:
A REST API may be different from, for example, a simple object access protocol (SOAP) API. A SOAP API uses extensible markup language (XML) to transfer data. SOAP APIs require advanced security and more bandwidth than a REST API. SOAP APIs cannot cache. A REST API may also be different from an extensible markup language-remote procedure calls (XML-RPC) API. An XML-RPC API utilizes a specific XML format to transfer data. A client performs an RPC by sending an HTTP request to a server that implements XML-RPC. The server returns an HTTP response. A REST API may also be different from a JavaScript object notation (JSON)-RPC API. A JSON-RPC API works the same way as an XML-RPC API but uses JSON instead of XML format.
According to some aspects, the CAD API 408 may handle multi-threading instead of having a user handle multi-threading. Similarly, the CAD API 408 may handle GPU implementations and/or accelerations instead of a user. Still further, the CAD API 408 may handle GPU and/or CPU based multi-threading instead of a user.
The client device 500 may be implemented with the processing system 502 that includes one or more processors 504. Examples of processors 504 include microprocessors, microcontrollers, digital signal processors (DSPs), field programmable gate arrays (FPGAs), programmable logic devices (PLDs), state machines, gated logic, discrete hardware circuits, and other suitable hardware configured to perform the various functionality described throughout this disclosure. In various examples, the client device 500 may be configured to perform one or more of the functions described herein. That is, the processor 504, as utilized in the client device 500, may be used to implement any one or more of the processes and procedures described herein.
In this example, the processing system 502 may be implemented with a bus architecture, generally represented by bus 508. Bus 508 may include any number of interconnecting buses and bridges depending on the specific application of the processing system 502 and the overall design constraints. The bus 508 links together various circuits, including one or more processors (represented generally by the processor 504), a memory 510, and computer-readable media (represented generally by the computer-readable medium 512). The bus 508 may also link various other circuits such as timing sources, peripherals, voltage regulators, and power management circuits, which are well known in the art and not described further.
A bus interface 514 may provide an interface between bus 508 and a transceiver/communication interface 516, which may provide a means for communicating with various other apparatus over a transmission medium (e.g., WAN/LAN, wired, and/or wireless interface).
A graphics processing unit (GPU) 520 may be provided. The GPU 520 may be coupled to the processor 504 via the bus 508. The GPU 520 may be a processor designed to accelerate graphics rendering and/or perform or accelerate the performance of other functions. The GPU may include memory (not shown). The GPU 520 may be optional.
A user interface 518 may be provided. The user interface 518 may provide a way for a user to input data to and obtain data from the client device 500. The data may be text, video, audio, or any combination thereof. The user interface 518 may include, for example, a keypad, a display, a touch screen, a speaker, a microphone, one or more switches, one or more control knobs, or any combination thereof. The preceding lists are exemplary and not limiting.
The processor 504 may be responsible for managing the bus 508 and general processing, including executing software stored on the computer-readable medium 512. When executed by the processor 504, the software may cause the processing system 502 (including the processor 504) to perform the various functions described herein for any particular apparatus. The computer-readable medium 512 and the memory 510 may also be used to store data manipulated by the processor 504 when executing software. For example, the memory 510 may store variable values, one or more final, and/or one or more intermediate solutions, as well as equations, to be executed commands, and data that is, in general, utilized by the processing system 502 (including the processor 504) to perform the various functions described herein for any particular apparatus.
One or more processors 504 in the processing system 502 may execute software. Software shall be construed broadly to mean instructions, instruction sets, code, code segments, program code, programs, subprograms, software modules, applications, software applications, software packages, routines, subroutines, objects, executables, threads of execution, procedures, functions, etc., whether referred to as software, firmware, middleware, microcode, hardware description language, or otherwise. The software may reside on a computer-readable medium 512.
The computer-readable medium 512 may be a non-transitory computer-readable medium. A non-transitory computer-readable medium includes, by way of example, a magnetic storage device (e.g., hard disk, floppy disk, magnetic strip), an optical disk (e.g., a compact disc (CD) or a digital versatile disc (DVD)), a smart card, a flash memory device (e.g., a card, a stick, or a key drive), a random access memory (RAM), a read only memory (ROM), a programmable ROM (PROM), an erasable PROM (EPROM), an electrically erasable PROM (EEPROM), a register, a removable disk, and any other suitable medium for storing software and/or instructions that may be accessed and read by a computer. The computer-readable medium 512 may reside in the processing system 502, external to the processing system 502, or distributed across multiple entities, including the processing system 502. The computer-readable medium 512 may be embodied in a computer program product. By way of example, a computer program product may include a computer-readable medium in packaging materials. In some examples, the computer-readable medium 512 may be part of the memory 510. Those skilled in the art will recognize how best to implement the described functionality presented throughout this disclosure depending on the application and the overall design constraints imposed on the system.
In some aspects of the disclosure, the processor 504 may include circuitry configured for various functions. For example, the processor 504 may include communication and processing circuitry/module 542, configured to communicate with one or more other client devices and/or one or more servers, such as, for example, the first server 112 through the nth server 116 as shown and described with reference to
In some implementations where the communication involves receiving information, the communication and processing circuitry/module 542 may obtain information from a component of the client device 500 (e.g., from the transceiver/communication interface 516 that receives the information via a wired or wireless type of signaling suitable for the applicable communication medium), process (e.g., decode) the information, and output the processed information. For example, the communication and processing circuitry/module 542 may output the information to another component of the processor 504, to the memory 510, the computer-readable medium 512, the user interface 518, and/or to the bus interface 514. In some examples, the communication and processing circuitry/module 542 may receive one or more of signals, messages, other information, or any combination thereof. In some examples, the communication and processing circuitry/module 542 may receive information via one or more channels. In some examples, the communication and processing circuitry/module 542 may include functionality for a means for receiving. In some examples, the communication and processing circuitry/module 542 may include functionality for a means for processing, including a means for demodulating, a means for decoding, etc.
In some implementations where the communication involves sending (e.g., transmitting) information, the communication and processing circuitry/module 542 may obtain information from another component of the processor 504, from the memory 510, from the computer-readable medium 512, from the user interface 518, and/or from the bus interface 514. In some examples, the communication and processing circuitry/module 542 may process (e.g., derive, modulate, encode, etc.) the obtained information and output the processed information. For example, the communication and processing circuitry/module 542 may output the information to the transceiver/communication interface 516 (e.g., transmitting the information via a wired connection, radio frequency signaling, or some other type of signaling suitable for the applicable communication medium). In some examples, the communication and processing circuitry/module 542 may send one or more signals, messages, other information, or any combination thereof. In some examples, the communication and processing circuitry/module 542 may send information via one or more channels. In some examples, the communication and processing circuitry/module 542 may include functionality for a means for sending (e.g., a means for transmitting). In some examples, the communication and processing circuitry/module 542 may include functionality for a means for generating, including a means for modulating, a means for encoding, etc.
The processor 504 may further include a computer aided design application programming interface (CAD API) circuitry/module 544, configured, for example, as an interface between the user interface 518 and a CAD application (such as the CAD application 416 as shown and described in connection with
The CAD API circuitry/module 544 of
According to some aspects, the CAD API circuitry/module 544 may call a local computation that may be handled by the processor 504 (or client device processor 404 as shown and described with reference to
According to some aspects, the server binary (e.g., the CAD application 416 resident on the server 410) may be run locally (at the server 410). According to this aspect, a user may access the server binary over a local network access, such as, for example, “localhost.” Alternatively, the server binary may be operated remotely (e.g., CAD API circuitry/module 544 may call a remote computation) by accessing the CAD application via the CAD API anywhere the server binary is hosted. The call for the remote computation may be made to the server 410. Examples of the server 410 include but are not limited to the first server 112 through nth server 116 as shown and described with reference to
In some examples, the CAD API circuitry/module 544 may provide a programmatic way to link a physical or a digital design to software elements, intelligence, automation, etc. For example, an object associated with a file may provide digital manufacturing instructions, or supply chain specifications, or other data relevant to other software elements, intelligence, automation, etc.
In some examples, the CAD API circuitry/module 544 may enable a remote CAD application, such as, for example, CAD application 416 on the server 410 as shown and described with reference to
Using the CAD API circuitry/module 544, a user may save a “script creation” and/or a “script created” version of a file as a secure file. Alternatively, the user may save the “script creation” and/or the “script created” version of the file as a non-secure file. The “script creation” version of the file may include the human readable script used to create the “script created” version of the file. The “script creation” version of the file may therefore be understood as a human-readable data file. The script may, for example, include human readable commands/instructions related to the design/generation of a given object having a given geometry. The “script created” version of the file may be created by the “script creation” file. The “script created” version of the file may include information (e.g., machine readable code) that describes the given geometry of the given object in a way that can be utilized, rendered, manipulated, analyzed, and/or optimized, etc. by a processing system (e.g., a processing system including a processor and computer-readable memory). The information of the “script created” version of the file (e.g., the information/machine code that describes the given object) may be referred to as the “actual object information.” The “script created” version of the file may therefore be understood as a non-human readable data file. In some examples, the “script creation” and/or “script created” file may be stored in a general location (not shown) in the computer-readable medium 512 as a secure or a non-secure file. In some examples, the “script creation” and/or “script created” file and may be stored in a secure file storage 560 location (e.g., an access restricted/encrypted location) in the computer-readable medium 512 as a secure or a non-secure file. Examples of a secured file include, but are not limited to, a signed file and a non-fungible token.
Using the CAD API circuitry/module 544, a user may cause a CAD application, such as the CAD application 416 as shown and described with reference to
In some examples, the CAD API circuitry/module 544 may include one or more hardware components that provide the physical structure that performs processes related to computer-aided design. The CAD API circuitry/module 544 may further be configured to execute CAD API instructions (software) 554 stored in the computer-readable medium 512 to implement one or more of the features, functions, aspects, and/or methods described herein that may be related to using the CAD API as described herein.
The processor 504 may further include scripting language circuitry/module 546, configured to provide and utilize a scripting language created to interact with a CAD application, such as CAD application 416, as shown and described with reference to
For example, in addition to geometric operations, also included in the scripting language described herein may be the facility for computer aided manufacturing (CAM) focused operations. In general, while providing for programmable geometry, the CAD application and associated CAD API described herein may also enable the ‘programmability’ of any aspect of CAD and/or CAM, including but not limited to the steps from the formulation of an idea for a project and a product thereof, through specification, analysis, test, planning of a manufacturing process, and manufacturing of the physical product using the manufacturing process. The accomplishment of all steps may be facilitated by a unified and coordinated “behind the scenes” approach (as described herein) to handling all these steps. A system, including a CAD application and associated CAD API and scripting language (as described herein), which handles these steps in a unified, coordinated, behind the scenes, and seamless manner is not known to exist. Instead, the aspects including but not limited to system engineering, design, analysis, build/manufacturing, up thorough and including final product testing are not seamlessly handled behind the scenes via the use of a single CAD application and associated CAD API and scripting language. Instead, they are more or less patched in on a one-off basis and require a great deal of separate human team interactions during and between the steps. According to some aspects, the scripting language described herein may or may not include a visual/rendering element.
The scripting language circuitry/module 546 may be used to execute a scripting language that may implement any one or more of the following exemplary features and may be used to achieve the handling of the above-described steps (as well as other CAD/CAM related steps) in a unified, coordinated, behind the scenes, and seamless manner. In other systems, as illustrated using the workflow of
By way of an analogy, the CAD application and associated CAD API and scripting language described herein may define a cube. All designs may make use of the defined cube. In other words, all systems refer to the defined cube. Utilizing the CAD application and associated CAD API and scripting language described herein, a user can update the parameters associated with the cube (e.g., change a bolt pattern and/or a bracket), and once updated, every system utilizing the defined cube may be updated automatically in a unified, coordinated, behind the scenes, and seamless manner. In contrast, with known ‘scriptable’ CAD, the one cube may exist in several systems. Still, a change to the cube means that a user must manually update the changed cube in each system employing the cube, pay attention to anything and everything that makes use of any portion of the cube (e.g., square projections of the cube, sketches incorporating the cube, edges where one or more edges includes the cube, surfaces where one or more surfaces include the cube, solids that include/incorporate the cube, complex objects of a multitude of features that include any feature of the cube, brackets that attach to the cube, etc.) making sure that all systems are updated as necessary, or manually call the update herself. In short, the CAD application and associated CAD API and scripting language described herein may enable the black-boxing of an entire project process, not just the design (geometric scripting) process. The CAD application and associated CAD API and scripting language described herein may be thought of as being used to convert a known manual hardware process into a continuous integration (CI)/continuous deployment (CD) (or continuous delivery (CD)) code pipeline. As used herein, CI may refer to the automation of the building and testing of an application on every new commit (i.e., save of an updated version). As used herein, continuous deployment (CD) may refer to the automation of the building, testing, and deploying of an application, where if all tests pass, every new commit may push new code (or any new hardware changes, changes in general, etc.) through an entire development pipeline to production with no manual intervention. Accordingly, in a first sense, continuous integration/continuous deployment (CI/CD) may be understood as the automatic manufacturing of a new design once it passes through the CI/CD processes, without human intervention. In a second sense, however, CI/CD may be understood as continuous integration/continuous delivery (CI/CD), where continuous delivery may refer to a state where the application is always ready to be deployed. According to this second sense, continuous integration/continuous delivery (CI/CD) may employ a manual step to actually deploy the application (or code, hardware changes, changes in general, etc.).
In some examples, the scripting language for CAD may allow for version control. As used herein, version control may be different from that used in Git, Subversion (SVN), Mercurial, Hg, Microsoft Teams Server, or Perforce, for example. The preceding list is exemplary and not limiting.
In some examples, the scripting language for CAD may be unit tested. Unit testing may be a software testing method by which individual units of source code are tested to determine whether they are fit for their specified purpose. In addition to capturing whether the code is behaving correctly (e.g., fit for its specified purpose), unit testing may also have the ability to verify through engineering analysis, geometry analysis, etc., that a given designed physical object matches specific requirements and the intent of the design, for example. As used herein, source code may mean sets of one or more computer program modules plus their associated control data, usage procedures, and operating procedures.
In some examples, the scripting language for CAD may be automatically verified.
In some examples, the scripting language for CAD may be automatically deployed.
In some examples, the scripting language for CAD may programmatically design physical or digital designs.
In some examples, the scripting language for CAD may programmatically design physical or digital designs, with or without human intervention.
In some examples, the scripting language for CAD may allow for a continuous spectrum of material properties.
In some examples, the scripting language for CAD may allow object oriented programming of CAD features. As used herein, the term “object oriented programing” may refer to a computer programming model that organizes software design around objects and classes rather than functions and logic.
In some examples, the scripting language for CAD may allow data oriented programming of CAD features. Data oriented programming is a programming language where values of the same type are commonly grouped together in memory. In contrast, object oriented programming focuses more on abstraction away from the data itself, putting items in container-like groupings where access to the memory is more restricted, but easier understandable. For example, data oriented design/programming of a group of students is a list of names with a list of ages; whereas object oriented design is a list of students who each have a name and an age.
In some examples, the scripting language for CAD may allow graphic processor unit (GPU) optimization. As used herein, GPU optimization may mean optimizing code to use the GPU specifically, for most if not all operations called by a user. GU optimization may additionally or alternatively mean using GPU-based multi-threading for most operations and optimizing most, if not all algorithms, to be on the GPU itself.
In some examples, the scripting language for CAD may be multithreaded.
In some examples, the scripting language for CAD may load and edit a CAD file programmatically. By use of the scripting language described herein, changes may be made automatically through scripts and/or API calls created by a user, rather than edits made manually by the user as requested through (e.g., via) a GUI.
In some examples, the scripting language for CAD may treat all CAD features (coordinate systems, sketches, solids, surfaces, edges, etc.) as objects which can be accessed programmatically.
In some examples, the scripting language for CAD may allow programmatic engineering drawing creation.
In some examples, the scripting language for CAD may automatically generate engineering drawings.
Still further, the scripting language circuitry/module 546 may be configured to execute scripting language instructions (software) 556 stored in the computer-readable medium 512 to implement one or more of the exemplary features described above, as well as any other features, functions, aspects, and/or methods described herein that may be related to use of a scripting language as described herein.
At 604, the processor of the client device may receive a response to the user request as output of a data processing pipeline. According to some aspects described herein, the data processing pipeline may terminate at the GUI or the CAD API. For example, the transceiver/communication interface 516, the communication and processing circuitry/module 542, the CAD API circuitry/module 544, and/or the processor 504, all of the client device 500 of
The server 700 may be implemented with the processing system 702 that includes one or more processors 704, a bus 708, memory 710, a computer-readable medium 712, a bus interface 714, a graphics processing unit (GPU) 720, a transceiver/communication interface 716, and a user interface 718, all similar to the similarly named components of the client device 500 as shown and described in connection with
In some aspects of the disclosure, the processor 704 may include circuitry configured for various functions. For example, the processor 704 may include communication and processing circuitry/module 742, configured to communicate with one or more other servers and/or one or more client devices. Exemplary servers may include the first server 112 through the nth server 116 of
In some aspects, the processor 704 may include CAD API circuitry/module 744. The features and functions attributed to the CAD API circuitry/module 744 of
The processor 704 may further include a scripting language circuitry/module 746, configured to provide and utilize a scripting language created to interact with a CAD application, such as one that may be executed by the CAD application circuitry/module 748. Accordingly, the scripting language may be referred to as a scripting language for CAD. According to some aspects, the scripting language may include scripting language for geometric operations in addition to other operations. According to some aspects, the scripting language may or may not include a visual/rendering element. The scripting language circuitry/module 746 may be used to implement one or more exemplary features described with reference to the scripting language circuitry/module 546; accordingly, the descriptions are not repeated to avoid duplication.
Still further, the scripting language circuitry/module 746 may be configured to execute scripting language instructions (software) 756 stored in the computer-readable medium 712 to implement one or more of the exemplary features described above, as well as any other features, functions, aspects, and/or methods described herein that may be related to use of a scripting language as described herein.
The processor 704 may further include a CAD application circuitry/module 748, configured to provide a CAD application that may interface to, for example, the CAD API circuitry/module 744. In some examples, the CAD application circuitry/module 748 may include one or more hardware components that provide the physical structure that performs processes related to computer aided design. Still further, the CAD application circuitry/module 748 may be configured to execute CAD application instructions (software) 758 stored in the computer-readable medium 712 to implement one or more of the exemplary features described above, as well as any other features, functions, aspects, and/or methods described herein that may be related to the use of a CAD application as described herein.
The computer-readable medium 712 may further include secure file storage 760, user credentials/keys 762, and/or licensing information 764, all the same or similar to like-named features described with reference to the computer-readable medium 512 of the client device 500 of
Systems enabled with the CAD application and associated CAD API and scripting languages described herein may form a cloud computing platform that may be used to process, transform, and render geometric data designed in the CAD GUI or through any programming language over a REST API.
At 804, the processor may create a data processing pipeline with one or more API endpoints based on the received data's characteristics and the user request. At 806, the processor may process the data through the data processing pipeline. For example, the communication and processing circuitry/module 742 of
At 808, the processor may return a response to the user request as output of the data processing pipeline to the GUI or the CAD API. For example, the communication and processing circuitry/module 742 and/or the transceiver/communication interface 716 of
One or more of the components, processes, features, and/or functions illustrated in
The word “exemplary” is used herein to mean “serving as an example, instance, or illustration.” Any implementation or aspect described herein as “exemplary” is not necessarily to be construed as preferred or advantageous over other implementations or aspects described herein.
Likewise, the term “aspects” does not require that all aspects of the disclosure include the discussed feature, advantage, or mode of operation.
The term “coupled” is used herein to refer to the direct or indirect coupling between two objects. For example, if object A physically touches object B, and object B touches object C, then objects A and C may still be considered coupled to one another—even if they do not directly physically touch each other.
The construct “A and/or B” is used herein to mean “A,” “B,” or “A and B.”
Also, it is noted that various disclosures contained herein may be described as a process. Many of the operations of the processes can be performed in parallel or concurrently. In addition, the order of the operations may be re-arranged. A process is terminated when its operations are completed.
While the foregoing disclosure shows illustrative embodiments, it should be noted that various changes and modifications could be made herein without departing from the scope of the disclosure as defined by the appended claims. The functions, steps and/or actions of the method claims in accordance with the embodiments described herein need not be performed in any particular order. Furthermore, although elements of embodiments may be described or claimed in the singular, the plural is contemplated unless limitation to the singular is explicitly stated.
Those of skill in the art would understand that information and signals may be represented using various technologies and techniques. For example, data, instructions, commands, information, signals, bits, symbols, and chips that may be referenced throughout the above description may be represented by voltages, currents, electromagnetic waves, magnetic fields or particles, optical fields or particles, or any combination thereof.
Those of skill would further appreciate that the various illustrative logical blocks, modules, circuits, and algorithm steps described in connection with the embodiments disclosed herein may be implemented as electronic hardware, computer software, or combinations of both. To clearly illustrate this interchangeability of hardware and software, various illustrative components, blocks, modules, circuits, and steps have been described above generally in terms of their functionality. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the overall system. Skilled artisans may implement the described functionality in varying ways for each particular application. Still, such implementation decisions should not be interpreted as causing a departure from the scope of the present invention.
The steps of a method or algorithm, such as those depicted in
In one or more exemplary embodiments, the functions described may be implemented in hardware, software, firmware, or any combination thereof. If implemented in software as a computer program product, the functions may be stored on or transmitted over as one or more instructions or code on a computer-readable medium. Computer-readable media includes both non-transitory computer-readable storage media and communication media including any medium that facilitates transfer of a computer program from one place to another. A storage media may be any available media that a computer can access. By way of example, and not limitation, such computer-readable media can comprise RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, or any other medium that can be used to carry or store desired program code in the form of instructions or data structures and that can be accessed by a computer. Also, any connection is properly termed a computer-readable medium. For example, if the software is transmitted from a website, server, or other remote source using a coaxial cable, fiber optic cable, twisted pair, digital subscriber line (DSL), or wireless technologies such as infrared, radio, and microwave, then the coaxial cable, fiber optic cable, twisted pair, DSL, or wireless technologies such as infrared, radio, and microwave are included in the definition of medium. Disk and disc, as used herein, includes compact disc (CD), laser disc, optical disc, digital versatile disc (DVD), floppy disk and blu-ray disc where disks usually reproduce data magnetically, while discs reproduce data optically with lasers. Combinations of the above should also be included within the scope of computer-readable media.
The previous description of the disclosed embodiments is provided to enable any person skilled in the art to make or use the present invention. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the generic principles defined herein may be applied to other embodiments without departing from the spirit or scope of the invention. Thus, the present invention is not intended to be limited to the embodiments shown herein but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.
Although the present disclosure and its advantages have been described in detail, it should be understood that various changes, substitutions, and alterations can be made herein without departing from the spirit and scope of the disclosure as defined by the appended claims. Moreover, the scope of the present application is not intended to be limited to the particular embodiments of the process, machine, manufacture, composition of matter, means, methods and steps described in the specification. As one of ordinary skill in the art will readily appreciate from the disclosure of the present disclosure, processes, machines, manufacture, compositions of matter, means, methods, or steps, presently existing or later to be developed that perform substantially the same function or achieve substantially the same result as the corresponding embodiments described herein may be utilized according to the present disclosure. Accordingly, the appended claims are intended to include processes, machines, manufacture, compositions of matter, means, methods, or steps within their scope.
This application for patent claims priority to and the benefit of provisional patent application No. 63/281,572 entitled “Computer Aided Design System, Application, and Application Programming Interface” filed in the United States Patent and Trademark Office on Nov. 19, 2021, the entire content of which is incorporated herein by reference as if fully set forth below in its entirety and for all applicable purposes.
| Number | Date | Country | |
|---|---|---|---|
| 63281572 | Nov 2021 | US |