BACKGROUND

[0001] Computer systems can be used to create, use, and manage data for products and other items. Examples of computer systems include computer- aided design (CAD) systems (which may include computer-aided engineering (CAE) systems), visualization and manufacturing systems, product data management (PDM) systems, product lifecycle management (PLM) systems, and more. These systems may include components that facilitate the design and simulated testing of product structures and product manufacture.

BRIEF DESCRIPTION OF THE DRAWINGS

[0002] Certain examples are described in the following detailed description and in reference to the drawings.

[0003] Figure 1 shows an example of a client computing system that supports selective loading of interaction data for visualized elements of a CAD model.

[0004] Figure 2 shows an example architecture that supports selective loading of interaction data for visualized elements of a CAD model.

[0005] Figure 3 shows an example of candidate CAD faces that a model interaction engine may identify to support selective loading of interaction data. [0006] Figure 4 shows an example of proximate CAD faces that a model interaction engine may identify to support selective loading of interaction data.

[0007] Figure 5 shows an example of logic that a system may implement to support selective loading of interaction data for elements of a CAD model.

[0008] Figure 6 shows an example of a system that supports selective loading of interaction data for elements of a CAD model.

DETAILED DESCRIPTION

[0009] CAD systems and applications can be implemented in various ways. For instance, CAD applications may be offered as a cloud-based service, e.g., as a Software-as-a-Service (“SaaS”) offering in which client computing systems access centrally hosted CAD applications via locally implemented thin clients. In such client-server models, user access to CAD models may be a time-consuming and resource-consuming process, especially as CAD models continue to increase in size and complexity. Receiving and loading 3D CAD models from a server via thin clients may consume significant computing and network resources. In some cases, CAD systems can reduce (e.g., minimize) transmitted CAD model data to only what is required to visualize (e.g., display) a CAD model on a client computing system. As used herein, visualization data may refer to any CAD model data required by a client computing system to visualize a given CAD model.

[0010] Aside from visualization data, CAD applications may utilize other types of CAD model data to support various CAD functions and features, including CAD capabilities to interact with specific elements of a CAD model. Example interactions that a CAD application may support include CAD model element selection, dragging, context menu displays, heads-up displays, geometry analyses, and many other forms of interaction with CAD model elements. CAD model data used to support such interactions through a CAD application may be referred to as interaction data. In that regard, interaction data may include any CAD model data that supports user interaction with visualized CAD model elements of a CAD model. As used herein, interaction data and visualization data may be distinct, as visualization data allows a CAD system to visualize a CAD model whereas interaction data may support user interaction with different CAD model elements visualized via the CAD system.

[0011] Loading interaction data in SaaS-based CAD systems may incur additional resource, latency, and network consumption penalties. In some instances, interaction data may comprise a non-trivial amount of CAD model data needed to properly support CAD-based functionalities of CAD systems, as much as 30% of loaded CAD model data and at times more. Loading interaction data together with visualization data during initial model loading is one approach, but will incur additional latency and performance penalties to completely load a CAD model with the added interaction data upon user login to a CAD application. Another simplistic approach is to load interaction data for specific CAD model elements at the time of user interaction (e.g., at the time of a mouseover or mouse click over a given CAD model element). However, such approaches may incur lag and latency at the time such interactions occur to complete server queries for interaction data, and CAD application users may experience a noticeable delay when selecting or otherwise interacting with CAD model elements.

[0012] The disclosure herein may provide systems, methods, devices, and logic for selective loading of interaction data for visualized elements of a CAD model. As described in greater detail below, the selective interaction data loading features herein may support determination of candidate CAD faces visualized by a client computing system that a user may potentially interact with. In doing so, selective interaction data loading may leverage the idea that not all geometric elements of a given CAD model are realistic interaction candidates, including CAD model elements not even displayed in a current view or visualized CAD model elements that are too small for a user to realistically select.

[0013] Loading interaction data for all CAD model elements of a CAD model would result in wasted network bandwidth and resource consumption. As such, the features described herein may support culling of non-candidate CAD model elements as well as server queries for interaction data of determined interaction candidates without (unnecessarily) querying for interaction data of non-candidate CAD model elements. By doing so, the features described herein may selectively load interaction data for a candidate subset of geometric entities in a given CAD model (as low as 10% or lower), which may result in a reduction in data to query, download, and locally store as compared to other simplistic interaction data loading techniques.

[0014] These and other selective interaction data loading features and benefits are described in greater detail herein.

[0015] Figure 1 shows an example of a client computing system 100 that supports selective loading of interaction data for visualized elements of a CAD model. The client computing system 100 may take the form of a single or multiple computing devices such as application servers, compute nodes, desktop or laptop computers, smart phones or other mobile devices, tablet devices, embedded controllers, and more. In some examples, the client computing system 100 implements or executes a thin client of a CAD application, providing access to cloud-based implementations of CAD applications. The client computing system 100 may interact with a server computing system at which CAD model data is centrally stored, acting as a client in a client-server architecture to access to CAD applications, CAD models, and various CAD functionalities.

[0016] As an example implementation to support any combination of the selective interaction data loading features described herein, the client computing system 100 shown in Figure 1 includes an model visualization engine 108 and a model interaction engine 110. The client computing system 100 may implement the engines 108 and 110 (including components thereof) in various ways, for example as hardware and programming. The programming for the engines 108 and 110 may take the form of processor- executable instructions stored on a non-transitory machine-readable storage medium and the hardware for the engines 108 and 110 may include a processor to execute those instructions. A processor may take the form of single processor or multi-processor systems, and in some examples, the client computing system 100 implements multiple engines using the same computing system features or hardware components (e.g., a common processor or a common storage medium).

[0017] In operation, the model visualization engine 108 may access, from a server computing system remote to the client computing system 100, visualization data to display a CAD model in a viewing window of the client computing system. In operation, the model interaction engine 110 may query the server computing system for interaction data of a selected portion of the CAD model, but not other portions of the CAD model, wherein the interaction data comprises CAD model data that supports user interaction with the selected portion the CAD model. The selected portion of the CAD model determined by the model interaction engine 110 may include determined candidate CAD model elements that a user may potentially interact with, determined according to various interaction criteria as described in greater detail herein. These and other selective interaction data loading features according to the present disclosure are described in greater detail next.

[0018] Figure 2 shows an example architecture 200 that supports selective loading of interaction data for visualized elements of a CAD model. The example architecture 200 shown in Figure 2 includes a client computing system 100 and a server computing system 202. The client computing system 100 and server computing system 202 may together support a client- server (e.g., SaaS) based implementation of a CAD application, in which CAD software can be centrally hosted on a CAD application server (such as the server computing system 202) and accessed via thin clients implemented by client devices (e.g., the client computing system 100). To support such features, the client computing system 100 and server computing system 202 may be communicatively linked, e.g., via the Internet, local or wide area networks, etc.

[0019] The client computing system 100 as shown in Figure 2 includes the model visualization engine 108 and the model interaction engine 110. The model visualization engine 108 may include any capability to support visualization of CAD models by the client computing system 100. In that regard, the model visualization engine 108 may access visualization data for a CAD model and display the CAD model (or given views of the CAD model) via thin clients of the client computing system 100. In the example shown in Figure 2, the model visualization engine 108 provides a CAD application display through an application window 210 of a thin client, and example thin clients include web browsers, application portals, or light-weight client applications, or any other client that can interface with CAD software centrally hosted by the server computing system 202. As shown in Figure 2, the model visualization engine 108 may visualize the CAD model 212 in the application window 210, which may then support user interaction to access, modify, test, or otherwise configure the CAD model 212.

[0020] The model visualization engine 108 may access visualization data for the CAD model 212 from the server computing system 202. As CAD models continue to increase in complexity, visualization data may likewise increase in size and complexity. As such, the model visualization engine 108 may compress, reduce, or otherwise limit accessed visualization data for the CAD model 212 only to what is necessary to display the CAD model 212 in the application window 210. Put another way, visualization data of the CAD model 212 accessed by the model visualization engine 108 may support display of the CAD model 212, but may lack any data to support given user interactions with visualized elements (e.g., CAD faces) of the CAD model 212. Example forms of visualization data include CAD face data or mesh data to construct a rendering of the CAD model 212 to display in the application window 210.

[0021] To support CAD model interaction, the model interaction engine 110 may selectively load interaction data for some, but not all, of the visualized elements of the CAD model 212 displayed in the application window 210. As noted herein, interaction data may include CAD model data (aside from visualization data) that supports any user interaction with the CAD model 212 or selected portions thereof. Example of interaction data include edge data (e.g., when a CAD model can be visualized through CAD face data alone, without edge data), snap point data, tangent chaining data, feature selection data, geometry analytics data of the CAD model 212, and more. Such interaction data may support CAD model interactions in the form of selection, dragging, context menus, heads up displays, and so on.

[0022] To selectively load interaction data, the model interaction engine 110 may identify selected CAD model elements (e.g., CAD faces, assembly components, or any other delineated portion of a CAD model) as candidate CAD model elements that a user may potentially interact with, doing so by applying any number of interaction criteria to make such determinations. The determined set of candidate elements may comprise a set of candidate CAD model elements visualized in the application window 210 for which the model interaction engine 110 may selectively load interaction data for.

[0023] Many of the selective loading features described herein are presented using candidate CAD faces as example candidate CAD model elements the model interaction engine 110 may determine or identify. A CAD face may refer to any delineated surface in the CAD model, and may be visualized with multiple facets (e.g., as a surface mesh). However, any type of candidate CAD model element and corresponding interaction criteria contemplated in the scope of this disclosure. For instance, the model interaction engine 110 may identify candidate CAD components (e.g., comprised of multiple CAD faces or other CAD sub-parts) that are part of a larger CAD assembly. The interaction criteria and selective interaction data loading features may be consistently applied for candidate CAD components and/or any other type of CAD model elements that the model interaction engine 110 may determine as candidates for user interaction.

[0024] Interaction criteria may be set by the model interaction engine 110 with a goal of identifying realistic or likely candidates of the CAD model 212 that a user may interact with. Explained in another way, applied interaction criteria may filter non-realistic or non-likely CAD model elements of user interaction, and do so as controlled through specific parameters of the interaction criteria. In effect, applied interaction criteria may allow the model interaction engine 110 to load interaction data for a selected subset of visualized elements of the CAD model 212, thereby increasing efficiency and reducing network latencies as compared to simplistically loading interaction data for all visualized elements of the CAD model 212. Moreover, interaction criteria may allow the model interaction engine 110 to pre-load interaction data prior to actual user interaction, which may reduce or eliminate network latencies and application lag that may be prevalent for interaction data queries executed at or after actual user interaction.

[0025] Examples of interaction criteria that the model interaction engine 110 may apply are described in greater detail below in connection with Figures 3 and 4.

[0026] By applying interaction criteria, the model interaction engine 110 may determine a set of candidate CAD model elements (e.g., CAD faces) for a visualized CAD model 212. Referring again to Figure 2, the model interaction engine 110 may query the server computing system 202 for interaction data specifically for the determined candidate CAD faces. In Figure 2, the model interaction engine 110 constructs and sends the server query 220 to the server computing system 202. The server query 220 may request interaction data for the candidate CAD faces of the CAD model 212 as determined by the model interaction engine 110, but not for other non candidate CAD faces of the CAD model 212. The server computing system 202 may respond to the server query 220 with the server response 222, which may include the requested interaction data for the determined candidate CAD faces of the CAD model 212.

[0027] The interaction data for determined candidate CAD faces of the CAD model 212 is shown in Figure 2 as the interaction data 230, which the model interaction engine 110 may store locally in the client computing system 100. For instance, the model interaction engine 110 may store interaction data 230 in a client cache 240, which the model interaction engine 110 may itself implement or which may be otherwise locally implemented by the client computing system 100. Cached interaction data may be locally stored on the client computing system 100 and readily available for subsequent user interactions with the CAD model 212. Thus, the model interaction engine 110 may selectively load the interaction data 230 (e.g., into the client cache 240) for some, but not all, of the displayed elements of a CAD model.

[0028] Various examples of how the model interaction engine 110 may determine candidate CAD faces for which to selectively load interaction data are presented next in connection with Figures 3 and 4.

[0029] Figure 3 shows an example of candidate CAD faces that the model interaction engine 110 may identify to support selective loading of interaction data. In Figure 3, the application window 210 described in Figure 2 is again shown, which includes a viewing window 312 as labeled in Figure 3. The viewing window 312 may refer to a selected subsection of the application window 210 (e.g., a specific portion of a web browser), and may be any display portion specifically designated by a CAD application to display the CAD model 212. In that regard, the viewing window 312 may be separate from other components of a user interface (“Ul”) for a CAD application or application window 210, e.g., separate from web address bars, command ribbons, operation libraries, formatting bars, or other Ul components of a CAD application. Thus, the viewing window 312 may refer to an application- specific portion of a CAD application Ul to visualize and display a CAD model.

[0030] In some implementations, the model interaction engine 110 determines candidate CAD faces to selectively load interaction data based on attributes of the viewing window 312. In particular, the model interaction engine 110 may apply a size criterion with respect to the viewing window 312 to determine candidate CAD faces to selectively query interaction data for. Such a size criterion may be satisfied, for example, when the size of a given CAD face exceeds a threshold percentage (e.g., 10%) of a size of the viewing window 312, e.g., total size, width, height, etc. Through application of such a size criterion, the model interaction engine 110 may eliminate (relatively) smaller CAD faces as interaction candidates, and the size criterion may be configured to apply a threshold percentage of a size of the viewing window 312 so as to identify non-candidate CAD faces which are smaller in size, and thus less likely (or incapable) of user interaction for a presently visualized view of the CAD model 212.

[0031] To apply such a size criterion, the model interaction engine 110 may determine a size of the viewing window 312 and compute a size of each CAD face of the CAD model 212 visualized in the viewing window 312. In that regard, such a size criterion may be referred to as globally-applied size criterion as it may be applied to any CAD face as displayed in the viewing window 312 (and in doing so, the model interaction engine 110 may filter, from candidate determination, any CAD model element of the CAD model 212 that is not displayed in the viewing window 312). Computed sizes may be in the form of 2-dimensional (“2D”) areas, e.g., as measured in a 2D pixel space, perimeters, height or width values, diagonal values (e.g., of bounding boxes surrounding a CAD model element), or according to any other size parameter of the viewing window 312 and CAD model elements of a CAD model. Computation of CAD face sizes may be done specifically for a current view of the CAD model 212 as displayed in the viewing window 312. The model interaction engine 110 may identify, as a candidate CAD face, any given CAD face of the CAD model 212 with a size that exceeds at least a threshold percentage of the size of the viewing window 312.

[0032] As an illustrative example through Figure 3, the model interaction engine 110 may determine the viewing window 312 as having dimensions of 800 pixels x 600 pixels, and thus having a size of 480,000 pixels. In applying a size criterion with an example threshold percentage of 4%, the model interaction engine 110 may identify candidate CAD faces as any CAD face with a size greater than 19,200 pixels in the displayed view of the CAD model 212 in the viewing window 312. As another example implementation, the size criterion may be applied to diagonal values of bounding boxes surrounding CAD faces as compared to a threshold percentage of a diagonal value of the viewing window 312. In the example shown in Figure 3, the model interaction engine 110 may apply a size criterion to determine a set of candidate CAD faces labeled as candidate CAD faces 320 for the CAD model 212 displayed in the viewing window 312 (individual CAD faces patterned in black in Figure 3). Then, the model interaction engine 110 may query a CAD application server for interaction data of the candidate CAD faces 320 determined for the CAD model 212 displayed in the viewing window 312.

[0033] In some implementations, the model interaction engine 110 may re determine candidate CAD faces to selectively query interaction data for at triggering events. A triggering event may refer to any event determined by the model interaction engine 110 upon which the model interaction engine 110 selectively queries a CAD application server for interaction data. For instance, the model interaction engine 110 may identify size-based triggering events, which may refer to any event that changes the size of the viewing window 312 or the size of a threshold number of visualized elements of the CAD model 212 displayed in the viewing window 312.

[0034] Examples of size-based triggering events may include resizing of the viewing window 312, e.g., by maximizing the application window 210 or otherwise adjusting a CAD application Ul to increase or reduce the size of the viewing window 312. Other examples include changing a camera view of the CAD model 212 in the viewing window 312, whether by rotating a view of the CAD model 212 (thereby changing the 2D area of the CAD faces displayed in the viewing window 312, visualizing CAD faces of the CAD model 212 not previously displayed, removing of CAD faces that were visualized prior to the camera change, etc.) or by adjusting the zoom of the camera (either zooming in, which may increase the 2D area of displayed CAD faces, or by zooming out, which may decrease the area of displayed CAD faces).

[0035] Upon identification of any combination of the above-described triggering events, the model interaction engine 110 may re-determine candidate CAD faces for the CAD model 212 as displayed in the viewing window 312 and selectively load interaction data for the redetermined candidate CAD faces accordingly. The model interaction engine 110 may re-determine candidate CAD faces in a consistent manner as described above, globally applying a size criterion to an updated view of the CAD model 212 as changed by the triggering event.

[0036] As other examples of interaction criteria and triggering events, the model interaction engine 110 may determine candidate CAD faces based on proximity to cursor positions, described in greater detail next in connection with Figure 4.

[0037] Figure 4 shows an example of proximate CAD faces that the model interaction engine 110 may identify to support selective loading of interaction data. Proximate CAD faces may refer to CAD faces that the model interaction engine 110 may selectively load interaction data for based on an applied proximity criterion, e.g., with respect to a cursor or other Ul-based interaction mechanism. In that regard, proximate CAD faces may also be considered candidate CAD faces that the model interaction engine 110 may query a CAD application server for interaction data, but may be identified based on a proximity distance as opposed to size relative to a viewing window. That is, proximate CAD faces may be identified as potential interaction candidates based on a mouse cursor (or other Ul-based interaction mechanism) position. The model interaction engine 110 may determine the closer in distance a visualized CAD model element is to the mouse cursor, the more likely a user may interact with a particular CAD face or visualized CAD model element.

[0038] To illustrate, Figure 4 shows the application window 210 with a viewing window 412. The viewing window 412 shown in Figure 4 includes a cursor 414, by which a user may interact with (e.g., select or drag) visualized elements of the CAD model 212. To determine proximate CAD faces, the model interaction engine 110 may apply a proximity criterion that is satisfied when CAD faces of the CAD model 212 are within a proximity distance from the cursor 414. In Figure 4, the proximity distance is specified as a pixel distance and illustrated through the radius ‘r’ and the dotted circle that encompasses the tip of the cursor 414. Any CAD face in the CAD model 212 within a distance of ‘r’ pixels from the cursor 414 (e.g., cursor tip) may be identified as a proximate CAD face by the model interaction engine 110. [0039] The model interaction engine 110 may configure the proximity distance of a proximity criterion in various ways, for example as an explicit distance value (e.g., 50 pixel threshold distance), as a percentage of a dimension of the viewing window 412 (e.g., 5% of the width dimension of the viewing window 412), or in various other ways. As other examples, a proximity criterion applied by the model interaction engine 110 may applied through a bounding box surrounding the cursor 414 (e.g., a 100 pixel x 100 pixel bounding box with the tip of the cursor 414 at the center of the bounding box), or in any other form that provides a distance-based criterion by which the model interaction engine 110 can identify proximate CAD faces displayed in the application window 412.

[0040] In Figure 4, the model interaction engine 110 identifies the proximate CAD faces 420 for the view of the CAD model 212 displayed in the viewing window 412, and doing so based on the position of the cursor 414. The model interaction engine 110 may then query a CAD application server for interaction data of the proximate CAD faces 420 to support subsequent user interactions with any of the identified proximate CAD faces 420. As the cursor 414 changes positions, the model interaction engine 110 may continue to identify proximate CAD faces to selectively query a CAD application server for corresponding interaction data.

[0041] In some implementations, the model interaction engine 110 identifies some, but not all, CAD faces within a proximity distance from the cursor 414 as the proximate CAD faces 420 for which to selectively load interaction data. In such cases, the model interaction engine 110 may apply a secondary size criterion to CAD faces within the proximity distance. In a similar manner as discussed above for size criterion applied globally to a present view of the CAD model 212, the secondary size criterion may filter CAD faces that are too small to be likely interaction candidates, even when positioned less than the proximity distance from the cursor 414. However, the secondary size criterion may be referred as a locally-applied size criterion in that the model interaction engine 110 may apply the secondary size criterion only to CAD faces positioned within a proximity distance from the cursor 414.

[0042] The secondary size criterion may be applied in addition to the globally-applied size criterion used to determine candidate CAD faces based on a size of the viewing window (e.g., as described above for Figure 3). In some implementations, the secondary size criterion may specify a looser size threshold than the size criterion applied generally (e.g., globally) to the CAD model 212. Put another way, a greater number of CAD faces of the CAD model 212 may satisfy the secondary size criterion (if applied globally) than the size criterion used to determine the candidate CAD faces of the CAD model 212 as described in Figure 3.

[0043] To illustrate, the secondary size criterion may be satisfied when a given CAD face has a size that is at least 2% of the size of the viewing window 412, whereas a globally-applied size criterion may require at least a 4% size of the viewing window 412. As such, the model interaction engine 110 may identify some proximate CAD faces in the CAD model based on proximity to the cursor 414 that were not or would not have been identified as candidate CAD faces based on the size criterion globally applied to the CAD model 212 (e.g., identified as the candidate CAD faces 320 in Figure 3), but are now identified as proximate CAD faces by being within the proximity distance from the cursor 414 and satisfying the secondary (looser) size criterion.

[0044] As described herein, the model interaction engine 110 may identify candidate CAD faces (which may include proximate CAD faces) to selectively load interaction data, including through application of size-based interaction criteria, proximity-based interaction criteria, or combinations of both.

[0045] In some implementations, the model interaction engine 110 queries a CAD application server for a specific subset of interaction data for identified candidate CAD faces, doing so based on a specific application context or mode in which a CAD application operates. A CAD application may provide multiple interaction capabilities through various CAD interaction operations, such as selection operations, dragging operations, geometric analyses operations, and many more. The model interaction engine 110 may query for selected interaction data of determined candidate CAD faces based on a current CAD interaction operation being used to interact with a CAD model.

[0046] As illustrative examples, the model interaction engine 110 may query a CAD application server for interaction data in the form of snap point data when the current CAD interaction operation used by a user for a CAD model is a selection operation. When the current interaction operation is instead a geometry analysis operation, the model interaction engine 110 may instead query the CAD application server for geometry analytics data (and not snap point data). By doing so, the model interaction engine 110 may limit queried interaction data to apply specifically to the CAD interaction operation presently selected/used for a CAD application. Querying for selected forms of interaction data may reduce overall amount of queried interaction data, and thus reduce the consumed network bandwidth required to retrieve interaction data and improve the efficiency of user interaction with CAD models in client-server based CAD application implementations.

[0047] To support querying of selected interaction data differing based on current CAD interaction operations, the model interaction engine 110 may differentiate caching of interaction data based on CAD interaction operation. For instance, the model interaction engine 110 may separate a client cache (e.g., the client cache 240 shown in Figure 2) into multiple different memories, whether as physically separate or logically separate. Each separated memory may cache interaction data for different CAD interaction operations or different types of interaction data (e.g., a first cache for storing snap point interaction data, a second cache for storing geometry analytics interaction data, etc.). Based on the current CAD interaction operation and constructed query to the CAD application server for identified candidate CAD faces, the model interaction engine 110 may cache received interaction data in a corresponding one of the multiple memories. [0048] Additionally or alternatively, the model interaction engine 110 may employ any number of cache indexing and eviction techniques to maintain local caches of client computing systems used to store interaction data. For an identified set of candidate CAD faces (which may include proximate CAD faces), the model interaction engine 110 may first filter any candidate CAD faces with interaction data already indexed (and thus stored) in a client cache, including doing so on a CAD interaction operation-specific basis. To illustrate, for an identified set of proximate CAD faces when the current CAD interaction operation for the CAD application is a selection operation, the model interaction engine 110 may filter, from server queries, any of the proximate CAD faces with snap point data already stored in a local cache designated for storing snap point interaction data. In a similar manner, the model interaction engine 110 may lookup entries in other interaction data caches to filter interaction data queries to a CAD application server. By doing so, the model interaction engine 110 may reduce or eliminate redundant queries for interaction data already loaded in the client cache from prior interaction data queries to the CAD application server.

[0049] Thus, the model interaction engine 110 may support selective loading of interaction data for selected portions of displayed CAD models.

[0050] Figure 5 shows an example of logic 500 that a system may implement to support selective loading of interaction data for visualized elements of a CAD model. For example, the client computing system 100 may implement the logic 500 as hardware, executable instructions stored on a machine-readable medium, or as a combination of both. The client computing system 100 may implement the logic 500 via the model visualization engine 108 and the model interaction engine 110, through which the client computing system 100 may perform or execute the logic 500 as a method to support selective interaction data loading. The following description of the logic 500 is provided using the model visualization engine 108 and the model interaction engine 110 as examples. Flowever, various other implementation options by systems are possible. [0051] In implementing the logic 500, the model visualization engine 108 may access visualization data to display a CAD model in a client computing system (502). The model visualization engine 108 may further use the access visualization data to display a view of the CAD model in the viewing window, e.g., as through a 3D-to-2D mapping for an initial or current camera view for displaying the CAD model.

[0052] In implementing the logic 500, the model interaction engine 110 may determine a set of candidate CAD faces of the CAD model displayed in the viewing window that satisfy a size criterion with respect to the viewing window (504). In that regard, the model interaction engine 110 may globally apply the size criterion to each of the CAD faces displayed in the current camera view of the CAD model. As noted herein, such a globally-applied size criterion may be satisfied when a size of a given CAD face exceeds a threshold percentage of a size of the viewing window.

[0053] Then, the model interaction engine 110 may query a server computing system for interaction data of the candidate CAD faces, and do so without querying the server computing system for interaction data of non candidate CAD faces of the CAD model that do not satisfy that size criterion (506). In such a manner, the model interaction engine 110 may selectively query a CAD application server for some, but not all, of the visualized elements of a CAD model in a current camera view. Upon receiving a server response to the query, the model interaction engine 110 may load a client cache with the interaction data provided by the server computing system (508).

[0054] As such, the model interaction engine 110 may selectively load interaction data for a current view of a CAD model. Responsive to identification of a triggering event, the model interaction engine 110 may redetermine candidate CAD faces based on a change in the viewing window, change in the displayed CAD model, or movement of mouse cursors or other Ul interaction mechanisms supported by a CAD application.

[0055] For instance, the model interaction engine 110 may identify size- based triggering events based on changes in camera view, camera zoom, or a resizing of the viewing window. Responsive to identifying any of these triggering events, the model interaction engine 110 may determine, for the updated camera view or resized viewing window, a redetermined set of candidate CAD faces that satisfy the size criterion with respect to the (possibly resized) viewing window (504), send another query to the server computing system for the redetermined set of candidate CAD faces (506), and load the client cache with the provided interaction data (508). In some instances, the model interaction engine 110 may filter the query such that already-cached interaction data for the redetermined candidate CAD faces (e.g., loaded from a previous query) is not re-loaded into the client cache.

[0056] Other examples of triggering events may be proximity based. In such examples, the model interaction engine 110 may track movement of a mouse cursor (or other Ul interaction mechanism). To illustrate, the model interaction engine 110 may identify movement of a cursor in the viewing window of the client computing system (510) and determine a set of proximate CAD faces of the CAD model within a proximity distance from the cursor (512). In some implementations, the model interaction engine 110 may apply a secondary (or local) size criterion for CAD faces within the proximity distance in order to determine the proximate CAD faces. Then, the model interaction engine 110 may query the server computing system for interaction data of the proximate CAD faces (514), which may also include filtering the query to account for already-cached interaction data.

[0057] In the various ways described above, the model interaction engine 110 may populate a client cache with interaction data for selected visualized elements of a CAD model, including accounting for different triggering events that may occur through active use of a CAD application by a user. Note that the model interaction engine 110 may support selective loading of interaction data into a client cache prior to user interaction with a given CAD face or visualized CAD model elements. Triggering events may be specifically identified by the model interaction engine 110 prior to user interaction (via selection, mouseover, dragging, etc.) of CAD model elements. Instead, the model interaction engine 110 may determine candidate CAD faces as the camera view changes or upon mouse movement proximate (but not yet at) CAD model elements, and querying for interaction data prior to actual user interaction.

[0058] By the time a user interacts with a given CAD model element via the CAD application, the model interaction engine 110 may already have loaded interaction data for the given CAD model element into a local client cache, which may thus support interactions with reduced latency and network consumption, while improving application performance.

[0059] To illustrate through Figure 5, the model interaction engine 110 may identify a user interaction in a CAD application through identifying cursor movement over a given CAD model element (516), such as an edge in the displayed CAD model. In response, the model interaction engine 110 may query a locally-implemented client cache for interaction data of the given CAD model element (518). As the given CAD model element may have been previously determined as a candidate CAD face, interaction data for the given CAD model element may have been selectively loaded into the client cache prior to the identified cursor movement over the given CAD model element. Accordingly, the model interaction engine 110 can retrieve the locally cached interaction data and support user interactions with the given CAD model element through the interaction data returned from the client cache (520).

[0060] The logic 500 shown in Figure 5 provides but one example by which a client computing system 100 may support selective loading of interaction data for visualized elements of a CAD model. Additional or alternative steps in the logic 500 are contemplated herein, including according to any features described for the model visualization engine 108, model interaction engine 110, or any combinations thereof.

[0061] Figure 6 shows an example of a system 600 that supports selective loading of interaction data for visualized elements of a CAD model. The system 600 may include a processor 610, which may take the form of a single or multiple processors. The processor(s) 610 may include a central processing unit (CPU), microprocessor, or any hardware device suitable for executing instructions stored on a machine-readable medium. The system 600 may include a machine-readable medium 620. The machine-readable medium 620 may take the form of any non-transitory electronic, magnetic, optical, or other physical storage device that stores executable instructions, such as the model visualization instructions 622 and the model interaction instructions 624 shown in Figure 6. As such, the machine-readable medium 620 may be, for example, Random Access Memory (RAM) such as a dynamic RAM (DRAM), flash memory, spin-transfer torque memory, an Electrically-Erasable Programmable Read-Only Memory (EEPROM), a storage drive, an optical disk, and the like.

[0062] The system 600 may execute instructions stored on the machine- readable medium 620 through the processor 610. Executing the instructions (e.g., the model visualization instructions 622 and/or the model interaction instructions 624) may cause the system 600 to perform any of the selective interaction data loading features described herein, including according to any of the features with respect to the model visualization engine 108, the model interaction engine 110, or a combination of both.

[0063] For example, execution of the model visualization instructions 622 by the processor 610 may cause the system 600 to access, from a server computing system remote to the system 600, visualization data to display a CAD model in a viewing window of the system 600. Execution of the model interaction instructions 624 by the processor 610 may cause the system 600 to determine a set of candidate CAD model elements of a CAD model displayed in a viewing window of the client computing system, including by determining the candidate CAD model elements satisfy a size criterion with respect to the viewing window and query a server computing system for interaction data of the candidate CAD model elements without querying the server computing system for interaction data of non-candidate CAD model elements of the CAD model that do not satisfy that size criterion,

[0064] Any additional or alternative features as described herein may be implemented via the model visualization instructions 622, model interaction instructions 624, or a combination of both. [0065] The systems, methods, devices, and logic described above, including the model visualization engine 108 and the model interaction engine 110, may be implemented in many different ways in many different combinations of hardware, logic, circuitry, and executable instructions stored on a machine-readable medium. For example, the model visualization engine 108, the model interaction engine 110, or combinations thereof, may include circuitry in a controller, a microprocessor, or an application specific integrated circuit (ASIC), or may be implemented with discrete logic or components, or a combination of other types of analog or digital circuitry, combined on a single integrated circuit or distributed among multiple integrated circuits. A product, such as a computer program product, may include a storage medium and machine-readable instructions stored on the medium, which when executed in an endpoint, computer system, or other device, cause the device to perform operations according to any of the description above, including according to any features of the model visualization engine 108, the model interaction engine 110, or combinations thereof.

[0066] The processing capability of the systems, devices, and engines described herein, including the model visualization engine 108 and the model interaction engine 110, may be distributed among multiple system components, such as among multiple processors and memories, optionally including multiple distributed processing systems or cloud/network elements. Parameters, databases, and other data structures may be separately stored and managed, may be incorporated into a single memory or database, may be logically and physically organized in many different ways, and may be implemented in many ways, including data structures such as linked lists, hash tables, or implicit storage mechanisms. Programs may be parts (e.g., subroutines) of a single program, separate programs, distributed across several memories and processors, or implemented in many different ways, such as in a library (e.g., a shared library).

[0067] While various examples have been described above, many more implementations are possible.