Computer-aided design systems, applications, and application programming interfaces
The CAD API and scripting language address resource limitations in CAD systems by enabling efficient use on devices with limited capabilities and automating design and manufacturing workflows, enhancing processor utilization and reducing redundancy.
Patent Information
- Application Number
- JP2024529735
- Authority / Receiving Office
- JP · JP
- Patent Type
- Applications
- Current Assignee / Owner
- Priority Date
- 2021-11-19
- Filing Date
- 2022-11-21
- Publication Date
- 2024-11-26
AI Technical Summary
Existing CAD systems face challenges in efficiently utilizing processor and memory resources, particularly on devices with limited capabilities, leading to difficulties in loading and running CAD applications, and require complex, repetitive workflows across multiple entities for design and manufacturing.
A CAD application programming interface (API) and scripting language that enables efficient use of processor resources, allowing CAD applications to be accessed and executed on devices with limited capabilities, and facilitates seamless integration of design, analysis, and manufacturing processes through a unified, automated workflow.
Enables efficient use of processor resources on devices with limited capabilities, streamlines complex CAD workflows, and automates design and manufacturing processes, reducing redundancy and improving accuracy by leveraging a common core that supports multiple sub-applications and functionalities.
Smart Images

Figure 2024543864000001_ABST
Abstract
Description
[Technical field]
[0001] CROSS-REFERENCE TO RELATED APPLICATIONS This patent application 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 with the U.S. Patent and Trademark Office on November 19, 2021, the entire contents of which are incorporated by reference herein for all applicable purposes as if fully set forth below.
[0002] 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. [Background technology]
[0003] Computer-aided design (CAD) relies on the processor and memory circuits (both working and storage memory) of a computer, sometimes called a computer workstation. CAD allows mechanical and electrical designs to be created, analyzed, modified, and optimized before physically executing the design. A design may be based on the compilation of modeled objects (e.g., goods or materials) that consist of one or more components, subassemblies, and assemblies. Each modeled object may be mathematically represented by one or more mathematical equations. The mathematical equations take into account a myriad of variables that define the modeled object. For example, a model of a steel beam may specify the shape (e.g., I-beam, T-beam), width, length, height, alloy type, hardness, tensile strength, elongation, fatigue strength, corrosion plasticity, melting point, and more. A model of an electrical capacitor may specify the shape (e.g., tip or leaded), width, length, height, form factor, capacitance, tolerances, temperature range, series resonant frequency, parasitic inductance, and more. The mathematical equations used to accurately model an object may require dozens of variables to obtain realistic results for analysis or optimization.
[0004] Furthermore, while component objects can be created and analyzed individually, to obtain the full benefit of a CAD system, the component objects must be combined to form subassemblies and assemblies. Thus, CAD systems may have the capability to model subassemblies that take into account interactions between the component objects, and may also have the capability to model assemblies that take into account interactions between the subassemblies as well as interactions between the modeled objects. This can place a heavy burden on the processor and memory circuitry of the computer using CAD. Summary of the Invention
[0005] Examples of implementations described herein include various systems, devices, methods, and servers, including, but not limited to, a system that implements a computer-aided design application and an associated computer-aided design application programming interface and scripting language, a client device that implements a computer-aided design application programming interface and scripting language associated with a computer-aided design application, a first method operating on a client device and implementing a computer-aided design application programming interface and scripting language associated with a computer-aided design application, a server that implements a computer-aided design application and an associated computer-aided design application programming interface and scripting language, and a second method operating on a server and implementing a computer-aided design application and an associated computer-aided design application programming interface and scripting language. [Brief description of the drawings]
[0006] [Figure 1] FIG. 1 is a schematic diagram of an environment in which a computer-aided design (CAD) system may reside, according to some aspects of the present disclosure. [Diagram 2] FIG. 2 is a flow diagram illustrating an example of a workflow involving multiple entities using multiple CAD applications, according to some aspects of the disclosure. [Diagram 3] FIG. 3 is a flow diagram illustrating an example of a workflow including a CAD application, a CAD application programming interface (API), and a scripting language, according to some aspects of the disclosure. [Figure 4] FIG. 4 is a schematic diagram of an environment in which a client device utilizes an application programming interface (API) to interface with a server hosting a CAD application, in accordance with some aspects of the disclosure. [Diagram 5]FIG. 5 is a block diagram illustrating an example of a hardware implementation of a client device employing a processing system according to some aspects of the present disclosure. [Figure 6] FIG. 6 is a flow diagram of a method operational in a client device according to some aspects of the disclosure. [Figure 7] FIG. 7 is a block diagram illustrating an example of a hardware implementation of a server employing a processing system according to some aspects of the present disclosure. [Figure 8] FIG. 8 is a flow diagram of a method operational in a server according to some aspects of the disclosure. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS
[0007] In the following description, specific details are presented to provide a thorough understanding of the described implementations. However, it will be understood by those skilled in the art that the implementations may be practiced without these specific details. For example, circuits may be shown in block diagrams or simplified representations so as not to obscure the implementations with unnecessary detail. In other instances, well-known circuits, structures and techniques may be shown in detail so as not to obscure the implementations.
[0008] FIG. 1 is a schematic diagram of an environment 100 in which a computer-aided design (CAD) system may exist, according to some aspects of the present disclosure. The CAD system may be embodied in an apparatus having a data input device, a data output device, a working memory, a storage memory, and a processor coupled to the data input device, the data output device, the working memory, and the storage memory. Examples of such devices include a personal computer 102, a laptop computer 104, a tablet computer 106, and the like. The above list is illustrative and not limiting. Before utilizing the CAD system, the personal computer 102, the laptop computer 104, and the tablet computer 106 may need to download an entire application (e.g., a software suite consisting of many software modules, a predefined object model, and the like). The download may be, for example, from a server, such as a first server 112, a second server 114, or an nth server 116 (n being an integer equal to or greater than 2), via the Internet 119. After the entire application is downloaded and stored in a storage memory (not shown) of the personal computer 102, laptop computer 104, or tablet computer 106, a processor (not shown) and associated working memory (not shown) can execute and use the application. The personal computer 102, laptop computer 104, and tablet computer 106 may each have a processor (not shown) capable of performing multiple calculations quickly, sometimes simultaneously, along with sufficient working memory to support performing the calculations in real time (e.g., with less undue delay than desired). This type of processor may use co-processors, multiple cores, or both, along with a sufficient amount of working memory (such as random access memory) to perform the calculations in real time.
[0009] Also shown in Figure 1 are other devices, including a smartphone 108 and a terminal 110 (e.g., a terminal itself or a computer with limited processing power or memory storage capacity). The above list is exemplary and not limiting. These other devices may not have the processor power, memory storage capacity, or both that a personal computer 102, a laptop computer 104, or a tablet computer 106 has. Thus, a smartphone 108, a terminal 110, or other devices with limited processing power and / or memory storage capacity may not be usable as a component of a CAD system because it may be difficult to load and run a CAD application on such a device.
[0010] 1, the personal computer 120, the laptop computer 104, the tablet computer 106, the smartphone 108, and the terminal 110 are all communicatively coupled to one or more first servers 112 through an nth server 116 over the Internet 118. The devices and servers may connect to the Internet 118 using any known type of communications network, such as a wired or wireless communications network known to those skilled in the art.
[0011] FIG. 2 is a flow diagram illustrating an example of a first workflow 200 involving multiple entities employing multiple CAD applications (e.g., CAD applications for systems engineering, design, analysis, manufacturing, and testing) according to some aspects of the disclosure. Any of the multiple CAD applications may be downloaded to any of the personal computer 102, laptop computer 104, and tablet computer 106 of FIG. 1. The download may be from any of the first server 112 to the nth server 116 of FIG. 1. The multiple CAD applications may not be downloaded to the smartphone 108 or terminal 110 of FIG. 1. Neither of these two devices have the processing power or memory required for one or more CAD applications.
[0012] At 202, a project request is made to a systems engineering 204 entity. The systems engineering 204 entity may utilize a systems CAD application (not shown) to create requirements 206 according to 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 of which are typically prepared by the systems engineering entity 204. The systems engineering entity 204 may also create requirements subsystems 208 developed from said requirements 206. The requirements 206 and requirements subsystems 208 may be transferred to a design entity 210.
[0013] A 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 recognize that one or more of the designed CAD models and prototype items 212 may not be able to converge (e.g., due to unrealistic requirements). Thus, the design entity 210 may declare a bottleneck 216. The declaration of the bottleneck 216 may trigger a bureaucracy to handle the bottleneck at block 218. Once the bottleneck is handled, the workflow 200 may be sent to block 220 for a bottleneck analysis. Once the bottleneck analysis is completed, at block 222, the bottleneck analysis may be combined with a review request.
[0014] Based on the review results at block 222, instructions may be given to the design entity 210 at block 224 to modify the design to accommodate the failed analysis. Alternatively or additionally, based on the review results at block 222, instructions may be given to the systems engineering entity 204 at block 226 to modify the original system and design requirements. If instructions are given to the systems engineering entity 204, the workflow 200 may return to creating a subsystem 208 of requirements. The systems engineering entity 204 may then provide the new requirements 208 to the design entity 210. If instructions are given to the design entity 210 at block 224 to modify the design to accommodate the failed analysis, the design entity 210 may again create the CAD model and prototype item 212. The workflow 200 may loop again as many times as necessary to overcome the obstacle 216.
[0015] Once the design has converged (214), the design entity 210 may forward the design to an analysis entity 228. The analysis entity 228 may utilize an analytical CAD application (not shown) to run simulations (e.g., any one or more of electrical, thermal, structural, design for maintainability (DFM), etc.) to predict success in block 230. The simulations run in block 230 may result in a failure 232, which again triggers the bureaucracy of block 218 to handle the failure. Alternatively, the simulations run in block 230 may be simulations used for failure analysis in block 220, simulations combined with failure analysis, and / or review requests in block 222. In these three situations, the workflow 200 returns to block 224, block 226, or both, and repeats the entire process of the previous workflow 200 as many times as necessary to overcome the failure (e.g., failure 216, failure 232, etc.).
[0016] Once the analysis is complete, the analysis entity 228 may forward the design to a build / make entity 234. The build / make entity 234 may use a build / make CAD application (not shown) to create a bill of materials and drawings that can be utilized and understood by a manufacturer, at block 236. Materials can then be purchased for the manufacture and assembly of the part, at block 238. However, at block 240, a tolerance issue, a previously overlooked defect, a manufacturing error, a human error, or a combination thereof may cause another roadblock 242. In such a situation, the workflow 200 returns to block 218 and repeats all of the processes of the previous workflow 200 starting from block 218 as many times as necessary to overcome any roadblocks (e.g., roadblock 216, roadblock 232, roadblock 242).
[0017] Once the build / make entity 234 has successfully completed the tasks, it may hand over responsibility of the project to a test entity 244. The test entity 244 may use a test CAD application (not shown) to test the product at block 246 to verify whether the product meets the original or revised requirements (as the case may be). However, at block 246, the testing may reveal that the product does not meet the requirements, and yet another fault 248 may be declared. In such a situation, the workflow 200 may return to block 218 and repeat all of the processes of the previous workflow 200 starting from block 218 as many times as necessary to overcome any faults (e.g., fault 216, fault 232, fault 242, fault 248), until finally, at block 250, the project may be successfully completed and the product may be built.
[0018] The processes described above in connection with workflow 200 of Figure 2 are not all of the processes involved in initially specifying a product and ultimately building the product. Other steps may be added, or the steps described may occur in an order not shown in Figure 2. However, to the extent that workflow 200 accurately describes a current workflow process that utilizes multiple CAD applications by multiple entities, it will be apparent to one of ordinary skill in the art that workflow 200 is complex and repetitive.
[0019] FIG. 3 is a flow diagram illustrating an example of a workflow 300 including a CAD application 306, a CAD application programming interface (API) 304 (also referred to as an API for CAD), and a scripting language (not shown) according to some aspects of the disclosure. At block 302, a project request may be made to a given entity (not shown). The given entity may use the CAD API 304 to input data to the CAD application 306 and receive data from the CAD application 306. The CAD application 306 may be used to meet system engineering requirements, design requirements, analysis requirements, construction / manufacturing requirements, and testing requirements. A given entity (i.e., one entity) or multiple entities (not shown) operating in parallel may use the CAD API 304 to perform all tasks of a product's life cycle (i.e., from initial request to final completion). Once the product's life cycle is complete, at block 308, the project is completed. The CAD API 304 may reside on a smartphone or terminal, such as the smartphone 108 or terminal 110 of FIG. 1. The CAD application 306 may reside on any of the first server 112 through the nth server 116 (individually or collectively referred to herein as a "server"). Because the CAD application 306 resides on a server, devices that have limited processing power, memory storage capacity, or both can use the CAD API 304 (which uses less processing power and memory storage capacity than a server) and benefit from the processor power and memory storage capacity of the server.
[0020] With respect to new scripting languages for use with CAD applications and / or CAD APIs, in some examples, scripts generated using the scripting languages described herein may not be automatically accessed, for example, but not limited to, according to one aspect, cannot be called by other scripts, called on a command line, deployed to the cloud and executed there (e.g., executing on a remote server, etc.).
[0021] The CAD application and associated CAD API described herein may utilize file types that may be new file types for CAD. As used herein, the term "file type" is used to refer to the functional and / or operational structure of a file (e.g., how a file is constructed / organized / used) and should not be confused with the term "file extension" which relates to how a file is named. Files that use CAD file types to store data may utilize digital certificates and / or include edit histories. Files that use CAD file types to store data may include functionality that allows files to be generated with a last access permission date, which is the date when access to the file is automatically terminated or when access to the file is revoked.
[0022] In some examples, files that store data using a CAD file type may be stored as non-fungible tokens (NFTs) on the blockchain.
[0023] In some examples, files that store data using a CAD file type may contain smart contracts on the blockchain (e.g., license agreements, resale agreements, profit sharing, etc.). As used herein, a smart contract on the blockchain is a program that is stored on the blockchain and executed when one or more predefined conditions are met. Using smart contracts, the execution of agreements can be automated, without the involvement of intermediaries or loss of time, and the results are immediately visible to all participants. Smart contracts can also be used to automate workflows and trigger the next action when predefined conditions are met.
[0024] In some examples, files that store data using a file type for CAD may be accessed programmatically as objects. As used herein, an "object" is a variable, data structure, function, or method that may be represented in memory and referenced by 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 filename and mass is a function call on the file partFile. Another example is an interaction using the form partFile.mass, where partFile is the filename and mass is a property of the file partFile. The file itself, as an object, may be found within a given project according to a predefined "folder" structure. The predefined folder structure may be configured to avoid the need to resolve file searches and to avoid the need to resolve name conflicts. As shown in the two examples above, files that are referred to as objects may be implemented in a variety of ways. The preceding examples are provided for illustrative purposes and are non-limiting.
[0025] In some examples, the file type itself may define which users / entities can view / manipulate the file and / or which machines can access / print / create the file. For example, a file that uses a file type for CAD to store data may programmatically define which users / entities or machines can access a given file. For example, the file type may implicitly indicate that a first brand of 3D printer can print the file, but a second brand of 3D printer cannot print the file. Or, as another example, the file type may implicitly indicate that a given machine shop (a first entity) can open the file, but a second machine shop (another entity, a second entity) cannot open the file.
[0026] In some examples, files that store data using CAD file types may allow programmatic access to CAD features (coordinate systems, sketches, solids, surfaces, edges, etc.) According to some examples, files that store data using CAD file types may allow programmatic access to CAD features in any programming language and on any operating system.
[0027] In general, the CAD applications and associated CAD APIs described herein may create code through user interaction with a graphic user interface (GUI). Conversely, the CAD applications and associated CAD APIs described herein may create code through GUI interaction with the user. In other words, the GUI may suggest to the user how to modify the model to achieve a desired result. For example, an example of direct interaction is filling in some given component. This filling may be toggled in the script as a user interface (UI) interaction or typing interaction, or directly in the GUI as a point-and-click interaction. For example, a user may want to place an item such as a vertex, cube, or line in a 3D coordinate system (x,y,z) or a 2D coordinate system (x,y). Instead of manually typing these values, the user may move to the location and point-and-click to identify the location. And vice versa. For example, as the user enters a value, the value may be automatically updated in the graphical representation of the value. Additionally, the user may be able to choose how the user and the CAD application interact. For example, one may choose to code to create what the user wants, using point and click and having the code generated automatically through the user's interaction with the GUI, or to code and use point and click, and then have the sections automatically generate aspects, or to manually generate aspects as the user sees fit.
[0028] FIG. 4 is a schematic diagram of an environment 400 in which a client device processor 404 of a client device 402 (e.g., a terminal) utilizes a CAD application user interface 406 (on the client device) and a first endpoint of a CAD application programming interface (CAD API 408A) to interface with a CAD application 416 hosted on a server 410 via a second endpoint of the CAD API 408B (on the server side). The user interface may be a graphical user interface or other user interface (which may not include graphical aspects and may be, for example, text-based and / or voice-based). The client device 402 (and the first endpoint of the CAD API 408A) and the server 410 (and the second endpoint of the CAD API 408B) may be communicatively coupled via the Internet 118 using any known type of communication network, such as a wired or wireless communication network known to those skilled in the art. Intermediate nodes forming a communication path between the CAD API 408A and the CAD API 408B are omitted to avoid cluttering the drawing. The client device 402 may be, for example, a personal computer 102, a laptop computer 104, a tablet computer 106, a smartphone 108, or a terminal 110, or any similar device, as shown and described with reference to FIG. 1. The server 410 may be, for example, any of the first server 112 to the nth server 116, as shown and described with reference to FIG. 1. The client device 402 may include a client device memory 420 coupled to the client device processor 404 via a communication bus 422. The server 410 may include a server memory 424 coupled to the server processor 412 via a communication bus 426.In some examples, no aspects of the CAD application 416 need to be loaded into the client device's memory 420, thereby making use of the first endpoint of the CAD API 408A and access to the CAD application 416 via the second endpoint of the CAD API 408B available to client devices that do not have advanced processors (e.g., minimal processing power such as found on smart phones or "dumb" terminals) and / or do not have a sufficient amount of memory to store the CAD application software / code. Indeed, the CAD APIs described herein and illustrated in FIG. 4 (comprised of the first endpoint of the CAD API 408A and the second endpoint of the CAD API 408B, collectively referred to as the CAD API 408) do not need to rely on software / code being installed locally on the client device 402. For example, in contrast, other APIs for CAD may require parent programs to be installed locally on the client device 402.
[0029] The CAD application 416 and associated CAD APIs (e.g., a first endpoint of CAD API 408A, a second endpoint of CAD API 408B, hereinafter collectively referred to as "CAD API 408") described herein may be designed to avoid the need to build more complex software 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 under multiple 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 CAD application 416). The multiple sub-applications may relate to respective functions of the CAD application 416, such as, but not limited to, design, modeling, analysis, optimization, testing, documentation, and manufacturing. Due to the comprehensive nature of the CAD application 416, it may not be necessary to build external programs on top of the CAD application 416.
[0030] In a sense, the common core 430 may form the foundation that supports multiple sub-applications that implement various functions of the CAD application 416. The multiple sub-applications may interact with and / or utilize native features of the common core 430. The multiple sub-applications may interact with each other directly or indirectly (e.g., through the common core 430) without invoking an external application (e.g., not interfacing with the common core 430). In a fundamental sense, the common core 430 is also referred to as a kernel or engine. However, the common core 430 of the CAD application 416 may be different from an operating system kernel, which is a computer program that is the core of a computer's operating system, as known to those skilled in the art. The operating system kernel has ultimate authority and may be the first to be launched when the computer processing system is powered on. In contrast, the common core 430 (kernel or engine) of the CAD application 416 described herein may be on top of an operating system kernel (not shown). There may be no intermediate program between the operating system kernel and the common core 430 of the CAD application 416.
[0031] In its fundamental position, the CAD application's 416 common core 430 may perform server-side operations, such as, but not limited to, basic mathematical operations (e.g., addition, subtraction, multiplication, division), to higher level operations (e.g., solutions of algebraic, geometric, and trigonometric functions), to even higher level operations (e.g., calculus, partial differential equations, differential equations, Fourier and inverse transforms, Laplace and inverse transforms, thermodynamics, static and dynamic mechanical engineering, structural engineering, materials science, environmental engineering, and electrical engineering functions), and logical operations (e.g., Boolean logic, etc.) that facilitate the operation of the sub-applications of the CAD application 416. Additionally, for illustrative and non-limiting purposes, the CAD application's common core 430 may perform services related to rendering, multi-threading of a graphics processing unit (GPU), and the like. Because the common core 430 of the CAD application 416 can perform all operations and functions of the various functions and sub-applications of the CAD application 416, the CAD application 416 may not need to call external programs that do not interface with the common core to implement the various functions provided by the CAD application 416. Thus, the use of the common core 430 can reduce redundancy, for example, by facilitating the use of shared common resources (i.e., the common core 430). Thus, the communication, speed, and energy (e.g., power) burdens on processors implementing known CAD systems (which may rely on multiple applications (e.g., external applications) that do not share a common core) can be reduced by use of the CAD application 416 described herein.
[0032] Additionally, the CAD application 416 and associated CAD API 408 may be designed to allow future improvements to its logic and intelligence, which may be added to the CAD application 416 and / or CAD API 408 over time. Because each sub-application utilizes the common core 430, some future improvements may only need to be pushed to or made to the common core 430. This may reduce redundancy and improve accuracy, as a single change to the common core may be used to implement future improvements to the entire CAD application 416 (rather than implementing future improvements by pushing changes to each of multiple sub-applications). Of course, nothing herein is intended to limit the implementation of future changes to the CAD application 416 or CAD API 408 to only changes to the common core 430.
[0033] CAD application 416 operates not only on objects, but also on subassemblies and assemblies contained within those objects. Objects range from basic two-dimensional and three-dimensional building blocks to objects that are themselves made up of multiple complex or detailed shapes (e.g., complex shapes). In addition to shape, each object may include parametric data that quantifies, for example, the qualities of the object and how the object responds to forces and the environment (e.g., each object may be associated with a host of parametric data that quantifies aspects of the object for purposes of at least design, modeling, analysis, optimization, testing, documentation, and manufacturing).
[0034] According to some aspects, the CAD API 408 described herein may be described as an API-first development 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, spreadsheets, circuit simulation, thermal analysis, continuous integration, engineering analysis, computer-aided manufacturing, physical inspection software, robotic path planning, enterprise resource planning, manufacturing resource planning, product lifecycle management, and / or supply chain optimization. Additionally, other applications may wrap the CAD API described herein for other use cases, such as, but not limited to, program management, financial planning, billing, procurement, and / or systems engineering.
[0035] In some examples, the CAD API 408 may be structured as a representational state transfer (REST) API (also referred to as a RESTful API). When structured as a REST API, the CAD API 408 allows commands to be invoked in any programming language (e.g., Python, JavaScript, Bash, Rust, Ruby, Golang, C, C++, COBOL, etc.), on any operating system (e.g., MacOS, iOS, Windows, Windows Phone, Windows Embedded, Microsoft Phone, Linux distributions, etc.). Commands 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 set of predefined operations. A REST API may be based on Uniform Resource Language (URL) and Hypertext Transfer Protocol (HTTP). REST is neither a protocol nor a standard. Instead, REST defines a set of six architectural constraints: 1. Client-server architecture - consists of clients, servers and resources, and requests are managed by HTTP. 2. Uniform Interface--Define an interface between clients and servers so that information is transferred in a standard form. 3. Stateless client-server communication - means that each request from client to server is independent. Furthermore, no client information is stored between GET requests, and each request is independent and not connected to any other request. 4. Cacheable - Maintain a cached response between client and server to avoid additional processing. 5. Layered system - Layers are arranged hierarchically. The system organizes each type of server involved (e.g., a server responsible for load balancing, a server responsible for security, etc.) and is invisible to the client. 6. Code on Demand - The ability to send executable code from the server to the client upon request, allowing the client to extend its functionality by downloading code to the client and executing the downloaded code in the form of applets or scripts.
[0036] 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. A SOAP API requires higher security and bandwidth than a REST API. A SOAP API cannot be cached. A REST API may also be different from an Extensible Markup Language-Remote Procedure Call (XML-RPC) API. An XML-RPC API uses a specific XML format for data transfer. A client executes 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 as an XML-RPC API, but uses JSON instead of the XML format.
[0037] According to some aspects, the CAD API 408 may handle multi-threading instead of having the user handle it. Similarly, the CAD API 408 may handle GPU implementation and / or acceleration on behalf of the user. Additionally, the CAD API 408 may handle GPU and / or CPU-based multi-threading on behalf of the user.
[0038] 5 is a block diagram illustrating an example of a hardware implementation of a client device 500 employing a processing system 502 according to some aspects of the disclosure. For example, the client device 500 may correspond to a personal computer, a laptop computer, a tablet computer, a smartphone, a terminal, or a similar device. Examples of client devices include the personal computer 102, the laptop computer 104, the tablet computer 106, the smartphone 108, and the terminal 110, all as described above with reference to FIG.
[0039] The client device 500 may be implemented using a processing system 502 that includes one or more processors 504. Examples of the processor 504 include a microprocessor, a microcontroller, a digital signal processor (DSP), a field programmable gate array (FPGA), a programmable logic device (PLD), a state machine, gate logic, discrete hardware circuitry, and other suitable hardware configured to perform various functions described throughout this disclosure. In various examples, the client device 500 may be configured to perform one or more functions described herein. That is, the processor 504 utilized in the client device 500 may be used to perform any one or more of the processes and procedures described herein.
[0040] In this example, the processing system 502 may be implemented with a bus architecture, generally represented by a bus 508. The bus 508 may include any number of interconnected buses and bridges, depending on the particular application and overall design constraints of the processing system 502. The bus 508 interlinks various circuits, including one or more processors (represented generally by processor 504), memory 510, and computer readable media (represented generally by computer readable media 512). The bus 508 may also link various other circuits, such as timing sources, peripherals, voltage regulators, power management circuits, etc., that are well known in the art and will not be described further.
[0041] The bus interface 514 provides an interface between the bus 508 and a transceiver / communications interface 516, which may provide a means for communicating with various other devices over a transmission medium (e.g., a WAN / LAN, a wired interface, and / or a wireless interface).
[0042] A graphics processing unit (GPU) 520 may be provided. The GPU 520 may be connected to the processor 504 via the bus 508. The GPU 520 may be a processor designed to accelerate image rendering and / or perform or accelerate the performance of other functions. The GPU may include memory (not shown). The GPU 520 may be optional.
[0043] A user interface 518 may be provided. The user interface 518 may provide a way for a user to input data to or retrieve data from the client device 500. The data may be text, video, audio, or a 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 above list is exemplary and not limiting.
[0044] The processor 504 may be responsible for general processing, including management of the bus 508 and execution of 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 device. The computer-readable medium 512 and the memory 510 may be used to store data that is manipulated by the processor 504 during execution of the software. For example, the memory 510 may store variable values, one or more final solutions, and / or one or more intermediate solutions, as well as equations, commands to be executed, and generally data utilized by the processing system 502 (including the processor 504) to perform the various functions described herein for any particular apparatus.
[0045] The one or more processors 504 of the processing system 502 can 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, executable files, threads of execution, procedures, functions, etc., whether referred to as software, firmware, middleware, microcode, hardware description language, or otherwise. The software may reside on computer-readable medium 512.
[0046] The computer readable medium 512 may be a non-transitory computer readable medium. The non-transitory computer readable medium may include, for example, a magnetic storage device (e.g., hard disk, floppy disk, magnetic strip), an optical disk (e.g., compact disk (CD), DVD), a smart card, a flash memory device (e.g., card, stick, key drive), a random access memory (RAM), a read only memory (ROM), a programmable ROM (PROM), an erasable PROM (EPROM) including electrically erasable PROM (EEPROM), a register, a removable disk, and any other suitable medium for storing software and / or instructions that can be accessed and read by a computer. The computer readable medium 512 may be resident in the processing system 502, may be external to the processing system 502, or may be distributed among multiple entities including the processing system 502. The computer readable medium 512 may be embodied as a computer program product. As an example, the computer program product may include the 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 to best implement the described functionality presented throughout this disclosure depending on the application and the overall design constraints imposed on the system.
[0047] In some embodiments of the present disclosure, the processor 504 may include circuitry configured for various functions. For example, the processor 504 may include a communication and processing circuit / module 542 configured to communicate with one or more other client devices and / or one or more servers, such as the first server 112 through the nth server 116, as shown and described with reference to FIG. 1. The communication may be performed via a transceiver / communication interface 516. In one example, the communication and processing circuit / module 542 may be configured to communicate with one or more servers (such as the first server 112 through the nth server 116 of FIG. 1) via an application processing interface, such as the CAD API 408, as shown and described with reference to FIG. 4. In some examples, the communication and processing circuit / module 542 may include one or more hardware components that provide a physical structure for performing processing related to computer-aided design.
[0048] In some implementations where communication includes receiving information, the communication and processing circuit / module 542 may obtain information from a component of the client device 500 (e.g., the transceiver / communication interface 516, which receives information via wired or wireless type signaling appropriate for the communication medium in question), process (e.g., decode) the information, and output the processed information. For example, the communication and processing circuit / module 542 may output information to another component of the processor 504, the memory 510, the computer-readable medium 512, the user interface 518, and / or the bus interface 514. In some examples, the communication and processing circuit / module 542 may receive one or more of a signal, a message, other information, or a combination thereof. In some examples, the communication and processing circuit / module 542 may receive information via one or more channels. In some examples, the communication and processing circuit / module 542 may include the functionality of a receiving means. In some examples, the communication and processing circuit / module 542 may include the functionality of a processing means, including demodulation means, decoding means, etc.
[0049] In some implementations where communication involves transmission (e.g., transmission) of information, the communication and processing circuit / 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 circuit / module 542 may process (e.g., derive, modulate, encode, etc.) the obtained information and output the processed information. For example, the communication and processing circuit / module 542 may output information to the transceiver / communication interface 516 (e.g., transmit the information via a wired connection, radio frequency signaling, or other type of signaling appropriate for the applicable communication medium). In some examples, the communication and processing circuit / module 542 may transmit one or more signals, messages, other information, or any combination thereof. In some examples, the communication and processing circuit / module 542 may transmit information over one or more channels. In some examples, the communication and processing circuit / module 542 may include the functionality of a transmission means (e.g., a transmission means). In some examples, the communication and processing circuit / module 542 may include functionality of a generating means, including a modulating means, an encoding means, and the like.
[0050] The processor 504 may further include a computer-aided design application programming interface (CAD API) circuit / module 544 configured, for example, as an interface between the user interface 518 and a CAD application (such as the CAD application 416 shown and described in connection with FIG. 4) hosted on a server (such as the first server 112 through the nth server 116 shown and described with reference to FIG. 1, or the server 410 shown and described with reference to FIG. 4).
[0051] The CAD API circuit / module 544 of FIG. 5 and / or the CAD API 408 of FIG. 4 (interchangeably referred to herein as the CAD API circuit / module 544) may be configured to be accessed through a license. Licensing allows for monetization of the CAD API circuit / module 544. The computer-readable medium 512 may store license information 564. The license information 564 may be used by the processor 504 to determine which features a given user is entitled to use from among a plurality of licensable features provided through the CAD API circuit / module 544. The user may be identified by a user credential / key 562 stored in the computer-readable medium 512. According to some aspects, the CAD API circuit / module 544 may be accessed through a license. It may be accessible via the Internet and may be used without downloading or locally running an associated CAD application. In some examples, the CAD API circuit / module 544 may not require a graphical user interface (e.g., another type of user interface, such as a text user interface (TUI) is within the scope of this disclosure). According to some aspects, the CAD API circuit / module 544 may have individual engines / portions / sub-applications that are monetized separately from other engines / portions / sub-applications, for example. For example, a physics engine (e.g., physics portion, physics sub-application) may be monetized separately from a rendering engine (e.g., rendering portion, rendering sub-application) and / or other aspects of the overall CAD application (e.g., file output requirements and data input requirements). Additionally, according to some aspects, the CAD API circuit / module 544 may be monetized per API call. For example, monetization may be done per computer resource (memory, CPU, GPU, threads, network, time, etc.) used by an API call.
[0052] According to some aspects, the CAD API circuitry / module 544 may invoke a local computation that may be processed by the processor 504 (or the client device processor 404 as shown and described with reference to FIG. 4). In such an embodiment, prior to the invocation, the client device 500 may be queried to determine whether the processor 504 (or the client device processor 404) and associated memory 510 (or the client device memory 420) are sufficient to perform the local computation.
[0053] According to some aspects, the server binary (e.g., CAD application 416 residing on server 410) may be executed locally (at server 410). According to this aspect, a user may access the server binary via a local network access, such as, for example, "localhost". Alternatively, the server binary may be operated remotely by accessing the CAD application via a CAD API wherever the server binary is hosted (e.g., CAD API circuitry / module 544 may invoke remote computation). Remote computation calls may be made to server 410. Examples of server 410 include, but are not limited to, first server 112 through nth server 116 as shown and described with reference to FIG. 1, and / or server 410 (or more specifically, server processor 412) as shown and described with reference to FIG. 4.
[0054] In some examples, the CAD API circuitry / modules 544 may provide a programmatic way to link a physical or digital design to software elements, intelligence, automation, etc. For example, an object associated with a file may provide digital manufacturing instructions, supply chain specifications, or other data related to other software elements, intelligence, automation, etc.
[0055] In some examples, the CAD API circuit / module 544 may enable a remote CAD application, such as the CAD application 416 on the server 410 as shown and described with reference to FIG. 4, to use voxels as interactive elements. Using voxels as interactive elements allows the CAD application 416 to render objects with unlimited detail. For example, using voxels as interactive elements allows infinite scroll-in and infinite scroll-out. This aspect allows complex objects such as Fibonacci objects to be created. The CAD application 416 may use solid multi-materials of the design itself, in addition to or instead of using voxels, using Constructive Solid Geometry Simulation (CSGS), Signed Distance Functions (SDF), Material Point Method (MPM), and / or other algorithmic techniques. These uses may improve applications for 3D printing and non-rigid project structures, for example.
[0056] Using the CAD API circuit / module 544, a user can save a "scripted" and / or "scripted" version of a file as a secure file. Alternatively, a user may save a "scripted" and / or "scripted" version of a file as a non-secure file. A "scripted" version of a file may include a human readable script that was used to create the "scripted" version of the file. Thus, a "scripted" version of a file may be understood as a human readable data file. The script may include, for example, human readable commands / instructions related to the design / generation of a given object having a given shape. A "scripted" version of a file may be created by a "scripted" version of a file. A "scripted" version of a file may include information (e.g., machine readable code) that describes a given geometry of a given object in a manner 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 (e.g., information / machine code that describes a given object) of a "scripted" version of a file may be referred to as "actual object information." Thus, a "scripted" version of a file can be understood as a non-human readable data file. In some examples, the "scripted" file and / or the "scripted" file may be stored as a secure or non-secure file in a general location (not shown) in the computer readable medium 512. In some examples, the "scripted" file and / or the "scripted" file may be stored as a secure or non-secure file in a secure file storage 560 location (e.g., an access restricted / encrypted location) in the computer readable medium 512. Examples of protected files include, but are not limited to, signed files, non-fungible tokens, etc.
[0057] Using the CAD API circuit / module 544, a user may have a CAD application, such as the CAD application 416 as shown and described with reference to FIG. 4, perform a project merge, which is similar to a code merge in computer coding technology. A project merge may be performed to consolidate multiple test, simulation, and scaling projects from a mechanical engineering or project design perspective. For example, in a code merge, a user may edit a project to add a new feature. If the project owner approves the new feature, the project owner may merge the new code (representing the new feature) into the project. Using the CAD API circuit / module 544, a user may request a CAD application, such as the CAD application 416 as shown and described with reference to FIG. 4, to automatically perform a function to "make sure the entire system of constraints that you defined is not broken." This function may be integrated into the merge system used to merge projects. As an example, a user may add a feature to a project, but the added feature may cause the project's thermal requirements to not be met (e.g., the added feature breaks a thermal specification). An example of such a feature is a user inadvertently blocking the airflow of a set of fans by changing a mold-injected plastic cover from one with certain holes to one without those certain holes. The user may make changes to the project. The CAD application, or its components or sub-applications, may run a thermal simulation automatically (e.g., without the user having to initiate the thermal simulation run). If the user violates the thermal specifications, the CAD application may alert the user, e.g., by highlighting the error, describing the error, or otherwise making the user aware of the error, and may not merge the user's changes until the user fixes the airflow problem.
[0058] In some examples, the CAD API circuitry / module 544 may include one or more hardware components that provide a physical structure for performing processing related to computer-aided design. The CAD API circuitry / module 544 may be further configured to execute CAD API instructions (software) 554 stored on the computer-readable medium 512 to perform one or more of the features, functions, aspects, and / or methods described herein that may be associated with use of the CAD API described herein.
[0059] The processor 504 may further include a scripting language circuit / module 546 configured to provide and utilize a scripting language created to interact with a CAD application, such as the CAD application 416, as shown and described with reference to FIG. 4. The scripting language may be referred to herein as a CAD scripting language. According to some aspects, the scripting language may include a scripting language for geometric and other operations.
[0060] For example, in addition to geometric operations, the scripting language described herein may include functionality for computer-aided manufacturing (CAM) focused operations. In general, while providing programmable geometry, the CAD applications and associated CAD APIs described herein may enable "programmability" of all aspects of CAD and / or CAM, including, but not limited to, steps from developing an idea for a project and its products, through specification, analysis, testing, planning a manufacturing process, and producing a physical product using the manufacturing process. Accomplishment of all steps may be facilitated by a unified and coordinated (as described herein) "behind the scenes" approach to handling all these steps. There is no known system in existence that includes a CAD application and associated CAD APIs and scripting languages (as described herein) that handles these steps in a unified, coordinated, behind the scenes, seamless manner. Instead, with a single CAD application and associated CAD APIs, scripting languages, the various aspects, including but not limited to systems engineering, design, analysis, construction / manufacturing, and final product testing, are not seamlessly handled behind the scenes. Instead, they are patched in more or less on a one-off basis, requiring a large amount of individual human team interaction during and between steps. According to some aspects, the scripting languages described herein may or may not include visual / rendering elements.
[0061] The scripting language circuit / module 546 can be used to execute a scripting language that can implement any one or more of the following exemplary functions, and can be used to realize the processing of the above steps (as well as other CAD / CAM related steps) in a unified, coordinated, behind-the-scenes, seamless manner. In other systems, as described using the workflow of FIG. 2, an individual may think, "I want this design, but the analysis is not working, so I need to manually go back to the system requirements I originally stated and adjust these requirements to achieve a manufacturable product," using native functionality such as a spreadsheet. In contrast, a user of a CAD application and associated CAD API and scripting language described herein can enter a command, such as, for example, "Adjust Design By Analysis," and the CAD API described herein can begin providing recommendations and / or automatically reconstructing the original design. Furthermore, if the system engineering requirements change, for example, from a customer's perspective, instead of spending human time discussing the changes among multiple teams and manually re-running various steps of the design and analysis process, a comprehensive pipeline based on the CAD application and associated CAD API and scripting language can be updated in response to the changes in the customer's system engineering requirements.
[0062] As an analogous example, a CAD application and associated CAD API, scripting language described herein may define a cube. All designs can use the defined cube. That is, all systems reference the defined cube. Using the CAD application and associated CAD API, scripting language described herein, a user can update parameters associated with the cube (e.g., change the bolt pattern and / or brackets). In contrast, in known "scriptable" CAD, a cube may exist in multiple systems. Yet, when a change is made to the cube, the user must manually update the changed cube in each system that uses it, take note of everything that uses any part of the cube (e.g., a square projection of the cube, a sketch that includes the cube, an edge with one or more edges that includes the cube, a surface with one or more surfaces that includes the cube, a solid that includes / incorporates the cube, a composite object of multiple features that includes any feature of the cube, a bracket that attaches to the cube, etc.), and ensure that all systems are updated as necessary or manually invoke the updates themselves. In other words, the CAD application and associated CAD API, scripting language described herein may achieve black-boxing of not only the design (geometric scripting) process, but the entire project process. The CAD application and associated CAD APIs and scripting languages described herein can be thought of as being used to transform known manual hardware processes into a continuous integration (CI) / continuous deployment (CD) (or continuous delivery (CD)) code pipeline. CI, as used herein, can mean automating the building and testing of an application with each new commit (i.e., the saving of an updated version).Continuous deployment (CD) as used herein means the automation of building, testing, and deployment of an application, where, once all tests pass, new code (or new hardware changes, general changes, etc.) can be pushed to production with each new commit throughout the development pipeline without manual intervention. Thus, in a primary sense, continuous integration / continuous deployment (CI / CD) can be understood as new designs being produced automatically without human intervention as they go through the CI / CD process. However, in a second sense, CI / CD can be understood as continuous integration / continuous delivery (CI / CD), where continuous delivery can mean that the application is always in a deployable state. According to this second sense, continuous integration / continuous delivery (CI / CD) can mean that manual steps are employed to actually deploy the application (or code, hardware changes, general changes, etc.).
[0063] In some examples, version control is possible through scripting languages for CAD. Version control as used herein may be different from that used in Git, Subversion (SVN), Mercurial, Hg, Microsoft Teams Server, Perforce, etc. The above list is illustrative and not limiting.
[0064] In some examples, a scripting language for CAD may be unit tested. Unit testing is a software testing methodology that tests individual units of source code to determine whether they are fit for a specified purpose. In addition to determining whether the code is working correctly (e.g., whether it is fit for a specified purpose), unit testing also serves to verify, for example, whether a designed physical object meets specific requirements or design intent through engineering analysis, geometry analysis, etc. As used herein, source code refers to a set of one or more computer program modules and their associated control data, usage instructions, and operating procedures.
[0065] In some instances, the CAD scripting language may be automatically verified.
[0066] In some instances, the CAD scripting language may be deployed automatically.
[0067] In some instances, CAD scripting languages allow for programmatic creation of physical or digital designs.
[0068] In some instances, CAD scripting languages allow for programmatic creation of physical or digital designs, with or without human intervention.
[0069] In some instances, the CAD scripting language allows for a continuous spectrum of material properties.
[0070] In some instances, CAD scripting languages allow object-oriented programming of CAD functions. As used herein, the term "object-oriented programming" refers to a computer programming model in which software design is centered around objects and classes, rather than functions and logic.
[0071] In some instances, the CAD's scripting language allows for data-oriented programming of the CAD functionality. Data-oriented programming is a programming language in which values of the same type are commonly grouped together in memory. In contrast, object-oriented programming focuses on abstraction away from the data itself, arranging items into container-like groups that have more limited access to memory but are easier to understand. For example, a data-oriented design / programming of a group of students would be a list of names and a list of ages, while an object-oriented design would be a list of students, each with a name and age.
[0072] In some instances, CAD scripting languages allow for Graphics Processor Unit (GPU) optimization. GPU optimization, as used herein, means optimizing the code to specifically use the GPU for most, if not all, operations invoked by the user. GPU optimization may additionally or alternatively use GPU-based multithreading for most processing and optimize most, if not all, algorithms for the GPU itself.
[0073] In some instances, the CAD scripting language may be multi-threaded.
[0074] In some examples, a CAD scripting language may programmatically read and edit a CAD file. Using the scripting language described herein, changes can be made automatically through user-created scripts and / or API calls, rather than manually edited by a user upon request via a GUI or the like.
[0075] In some instances, CAD scripting languages can treat all CAD features (coordinate systems, sketches, solids, surfaces, edges, etc.) as objects that can be accessed programmatically.
[0076] In some instances, CAD scripting languages allow for the programmatic creation of engineering drawings.
[0077] In some examples, CAD scripting languages may auto-generate engineering drawings.
[0078] Further, the scripting language circuit / module 546 may be configured to execute scripting language instructions (software) 556 stored on the computer-readable medium 512 to implement one or more of the example functions described above, as well as other features, functions, aspects, and / or methods described herein that may be associated with use of the scripting language described herein.
[0079] FIG. 6 illustrates an exemplary method 600 operating on a client device according to aspects described herein. At 602, a processor of the client device (a processor configured to execute instructions stored in a memory associated with the processor) may transmit data and user requests from a GUI or CAD API (e.g., as a direct call). For example, the transceiver / communication interface 516, the CAD API circuit / module 544, and / or the processor 504 of the client device 500 of FIG. 5 may provide a means for transmitting data and user requests (from the GUI or CAD API) according to some aspects described herein. As shown and described with reference to FIG. 5, the memory 510 of the client device 500 may provide a means for storing instructions, such as instructions executed by the processor to cause the processor to transmit data and user requests at 602. Additionally, the user interface 518 of the client device 500 of FIG. 5 may provide a means for a user to transmit data and user requests via the GUI or CAD API. Additionally, the CAD API may be a REST API as described herein.
[0080] At 604, the processor of the client device may receive a response to the user request as an output of the data processing pipeline. According to some aspects described herein, the data processing pipeline may terminate at a GUI or a CAD API. For example, the transceiver / communication interface 516, the communication and processing circuit / module 542, the CAD API circuit / module 544, and / or the processor 504 of the client device 500 of FIG. 5 may provide a means for receiving a response to the user request as an output of the data processing pipeline according to some aspects described herein.
[0081] 7 is a block diagram illustrating an example of a hardware implementation of a server 700 employing a processing system 702 according to some aspects of the present disclosure. For example, the server 700 may correspond to the first server 112 through the nth server 116 described above with reference to FIG. 1 or the server 410 described above with reference to FIG.
[0082] The server 700 may be implemented with a processing system 702 that includes one or more processors 704, a bus 708, memory 710, computer-readable medium 712, a bus interface 714, a graphics processing unit (GPU) 720, a transceiver / communications interface 716, and a user interface 718, all of which are similar to the like-named components of the client device 500 shown and described in connection with Figure 5. To avoid redundancy, the description of similar components will not be repeated.
[0083] In some aspects of the disclosure, the processor 704 may include circuits configured for various functions. For example, the processor 704 may include a communication and processing circuit / 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 to the nth server 116 of FIG. 1, or the server 410 of FIG. 4. Exemplary client devices may include the personal computer 102, laptop computer 104, tablet computer 106, smartphone 108, and / or terminal 110 of FIG. 1, the client device 402 of FIG. 4, and / or the client device 500 of FIG. 5. The communication may occur, for example, via the transceiver / communication interface 716. In one example, the communication and processing circuit / module 742 may be configured to communicate with the client device via an application programming interface, such as the second endpoint of the CAD API 408B as shown and described with reference to FIG. 4. Features and functions pertaining to the communication and processing circuit / module 742 of FIG. 7 may be the same or similar to the like-named features and functions as described for the communication and processing circuit / module 542 of FIG. 5 and will not be repeated herein to avoid redundancy. In some examples, the communication and processing circuit / module 742 may include one or more hardware components that provide a physical structure for performing processing related to computer-aided design. Additionally, the communication and processing circuit / module 742 may be configured to execute communication and processing instructions (software) 752 stored on the computer-readable medium 712 to perform one or more of the example functions described above, as well as other features, functions, aspects, and / or methods described herein that may relate to the use of CAD applications, CAD APIs, and scripting languages as described herein.
[0084] In some aspects, the processor 704 may include a CAD API circuit / module 744. Features and functions belonging to the CAD API circuit / module 744 of FIG. 7 may be the same as or similar to the like-named features and functions as described with reference to the CAD API circuit / module 544 of FIG. 5 and will not be repeated herein to avoid redundancy. In some examples, the CAD API circuit / module 744 may include one or more hardware components that provide a physical structure for performing processing related to computer-aided design. Furthermore, the CAD API circuit / module 744 may be configured to execute CAD API instructions (software) 754 stored on the computer-readable medium 712 to perform one or more of the example functions described above, as well as other features, functions, aspects, and / or methods described herein that may relate to the use of CAD applications, CAD APIs, and scripting languages as described herein.
[0085] The processor 704 may further include a scripting language circuit / module 746 configured to provide and utilize a scripting language created to interact with a CAD application, such as may be executed by the CAD application circuit / module 748. The scripting language may thus 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 visual / rendering elements. The scripting language circuit / module 746 may be used to implement one or more of the example functions described with reference to the scripting language circuit / module 546.
[0086] Further, the scripting language circuit / module 746 may be configured to execute scripting language instructions (software) 756 stored on the computer-readable medium 712 to implement one or more of the example features described above, as well as other features, functions, aspects, and / or methods described herein that may be associated with use of the scripting language described herein.
[0087] The processor 704 may further include a CAD application circuit / module 748 configured to provide a CAD application that may, for example, interface with the CAD API circuit / module 744. In some examples, the CAD application circuit / module 748 may include one or more hardware components that provide a physical structure for performing processing related to computer-aided design. Additionally, the CAD application circuit / module 748 may be configured to execute CAD application instructions (software) 758 stored on the computer-readable medium 712 to perform one or more of the example functions described above, as well as any other features, functions, aspects, and / or methods described herein that may be related to use of the CAD application described herein.
[0088] The computer readable medium 712 may further include secure file storage 760, user credentials / keys 762, and / or license information 764 that are the same as or similar to the like-named features described with reference to the computer readable medium 512 of the client device 500 of Figure 5. Thus, to avoid redundancy, the details of the like-named features will not be repeated herein.
[0089] A system supporting the CAD applications and associated CAD APIs and scripting languages described herein may form a cloud computing platform that can be used to process, transform, and render geometric data designed in a CAD GUI or through any programming language via a REST API.
[0090] FIG. 8 illustrates an example method 800 operating on a server hosting a CAD application according to aspects described herein. At 802, a processor of the server (a processor configured to execute instructions stored in a memory associated with the processor) may receive data and user requests. The data and user requests may be received from a GUI or directly called from a CAD API. For example, the transceiver / communication interface 716, the CAD application circuit / module 748, and / or the processor 704 of the server 700 of FIG. 7 may all provide a means for receiving data and user requests from a GUI or directly called from a CAD API according to some aspects described herein. As shown and described with reference to FIG. 7, the memory 710 of the server 700 may provide a means for storing instructions, such as instructions executed by the processor, to cause the processor to receive data and user requests at 802. Additionally, the user interface 518 of the client device 500 of FIG. 5 may provide a means for a user to send data and user requests via the GUI or the CAD API. Additionally, the CAD API may be a REST API as described herein.
[0091] At 804, the processor may create a data processing pipeline having one or more API endpoints based on characteristics of the received data and the user request. At 806, the processor may process the data through the data processing pipeline. For example, the communication and processing circuit / module 742 of FIG. 7 may provide means for creating a data processing pipeline having one or more API endpoints based on one or more characteristics of the received data and the user request, and means for processing the data through the data processing pipeline according to some aspects described herein.
[0092] At 808, the processor may return a response to the user request as an output of the data processing pipeline to the GUI or CAD API. For example, the communications and processing circuit / module 742 and / or the transceiver / communications interface 716 of FIG. 7 may provide a means for transmitting the output of the data processing pipeline to a GUI or CAD API according to some aspects described herein.
[0093] One or more of the components, processes, features, and / or functions illustrated in Figures 1 and 3-8 may be rearranged and / or combined into a single component, process, feature, or function or embodied in multiple components, processes, or functions, and additional elements, components, processes, and / or functions may be added without departing from the disclosure.
[0094] The word "exemplary" is used herein to mean "serving as an example, instance, or illustration." Any embodiment or aspect described herein as "exemplary" is not necessarily to be construed as preferred or advantageous over other embodiments or aspects described herein.
[0095] Likewise, the term "aspects" does not require that all aspects of the disclosure include the discussed feature, advantage or mode of operation.
[0096] As used herein, the term "coupled" refers to a direct or indirect connection between two objects. For example, if object A is in physical contact with object B, and object B is in contact with object C, then objects A and C are considered to be coupled to each other even though they are not in direct physical contact.
[0097] As used herein, the term "A and / or B" means "A," "B," or "A and B."
[0098] Also, it should be noted that various disclosures contained herein may be described as processes. Many of the operations of the processes may be performed in parallel or simultaneously. Further, the order of the operations may be rearranged. A process is terminated when its operations are completed.
[0099] Although the foregoing disclosure sets forth exemplary embodiments, it should be noted that various changes and modifications may be made herein without departing from the scope of the present 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. Further, although elements of the embodiments may be described or claimed in the singular, the plural is contemplated unless limitation to the singular is explicitly stated.
[0100] Those skilled in the art will appreciate that information and signals may be represented using a variety of technologies and techniques. For example, the data, instructions, commands, information, signals, bits, symbols, and chips 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.
[0101] Those skilled in the art will further appreciate that the various exemplary logic blocks, modules, circuits, and algorithm steps described in connection with the embodiments disclosed herein may be implemented as electronic hardware, computer software, or a combination of both. To clearly illustrate this interchangeability of hardware and software, the various exemplary 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 on 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. Nevertheless, such implementation decisions should not be interpreted as causing a departure from the scope of the invention.
[0102] The steps of a method or algorithm as depicted in FIG. 6 and FIG. 8 and described in connection with the embodiments disclosed herein may be embodied directly in hardware, in a software module executed by a processor, in a software module executed by a GPU, or in any combination of the above. The software modules may reside in RAM memory, flash memory, ROM memory, EPROM memory, EEPROM memory, registers, hard disk, removable disk, CD-ROM, or any other form of storage medium known in the art. An exemplary storage medium is coupled to the processor and / or GPU such that the processor and / or GPU can read information from and write information to the storage medium. Alternatively, the storage medium may be integral to the processor and / or GPU. The processor, GPU, and storage medium, or any combination of the processor, GPU, or storage medium, may reside in an ASIC. The ASIC may reside in a user terminal and / or a server. Alternatively, the processor, GPU, storage medium, or any combination thereof may reside as discrete components in a user terminal and / or a server.
[0103] 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 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 medium is any medium that can be accessed by a computer. By way of example, and not limitation, such computer-readable media may include RAM, ROM, EEPROM, CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage, 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 coaxial cable, fiber optic cable, twisted pair, digital subscriber line (DSL), or wireless technologies such as infrared, radio, microwave, etc., then the coaxial cable, fiber optic cable, twisted pair, DSL, or wireless technologies such as infrared, radio, microwave, etc., are included in the definition of media. As used herein, disk and diskette include compact disks (CDs), laser disks, optical disks, digital versatile disks (DVDs), floppy disks, and Blu-ray disks, where disks typically reproduce data magnetically and disks reproduce data optically with lasers. Combinations of the above should also be included within the scope of computer readable media.
[0104] 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 present 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.
[0105] 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 present 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 processes, machines, manufacture, compositions of matter, means, methods, and steps described herein. As will be readily understood by those skilled in the art from the disclosure of the present disclosure, any currently existing or later developed process, machine, manufacture, composition of matter, means, method, or step that performs substantially the same function or achieves substantially the same result as the corresponding embodiment described herein may be utilized in accordance with the present disclosure. Thus, the appended claims are intended to include within their scope any process, machine, manufacture, composition of matter, means, method, or step.
Claims
1. A server, A processor; a memory operatively connected to the processor; The processor, receiving data and user requests via an application programming interface (API) of a computer-aided design (CAD) application; creating a data processing pipeline having one or more API endpoints based on characteristics of the data and user requests; Processing data through said data processing pipeline; returning a response to the user request to the API of the CAD application as an output of the data processing pipeline; A server configured to:
2. Prior to performing local computation at the server, the processor further comprises: The server of claim 1 , configured to send a query to a client device via the API to determine whether a client device processor and a client device memory are sufficient to perform the local computation.
3. The server of claim 1 , wherein the data is contained in a file structured according to a file type associated with the CAD application, the file type being distinct from a file extension.
4. The server of claim 3 , wherein the files are accessed programmatically as objects.
5. The object is At least one of the following: a variable, a data structure, a function, or a method; Represented in said memory, 5. The server of claim 4, referenced by an identifier.
6. The processor further comprises: The server of claim 1 , configured to execute scripts obtained via the API and written using a scripting language associated with a CAD application.
7. The server of claim 6 , wherein the script is not accessible in an automated manner.
8. The server of claim 1 , wherein the CAD application is configured as a common core under a plurality of sub-applications, the plurality of sub-applications corresponding to respective functions of the CAD application.
9. The server of claim 8 , wherein the plurality of sub-applications utilize native functionality of the common core.
10. The server of claim 8 , wherein the common core sits above an operating system kernel.
11. 1. A method operational on a server, comprising: receiving data and user requests via an application programming interface (API) of a computer-aided design (CAD) application; creating a data processing pipeline having one or more API endpoints based on characteristics of the data and user requests; processing the data through the data processing pipeline; returning a response to the user request to an API of the CAD application as an output of the data processing pipeline.
12. 12. The method of claim 11, further comprising, prior to performing local computation at the server, sending a query via the API to a client device to determine whether a client device processor and client device memory are sufficient to perform local computation.
13. The method of claim 11 , wherein the data is contained in a file structured according to a file type associated with the CAD application, the file type being distinct from a file extension.
14. The method of claim 13 , wherein the files are accessed programmatically as objects.
15. The object is At least one of a variable, a data structure, a function, or a method, Represented in said memory, Referenced by an identifier, 15. The method of claim 14.
16. 12. The method of claim 11, further comprising executing a script obtained via the API and written using a scripting language associated with the CAD application.
17. The method of claim 16 , wherein the script is not accessible in an automated manner.
18. The method of claim 11 , wherein the CAD application is structured as a common core under multiple sub-applications, the multiple sub-applications corresponding to respective functions of the CAD application.
19. The method of claim 18 , wherein the plurality of sub-applications utilize native functionality of the common core.
20. 20. The method of claim 18, wherein the common core sits above an operating system kernel.
