High precision geometry system and method for thin client applications

Abstract

Systems and methods for efficient acquisition of high precision geometry for graphical objects on thin client applications, such as applications running on browsers or handheld devices. Specifically, a high-precision geometry client running on a client device sends a request to a corresponding high-precision geometry service running on a server system to obtain high-precision geometry primitives, the client device converts the high precision geometry primitives to tessellated geometry data and renders the tessellated geometry data on a display of the client device, offloading processor-intensive high precision geometry processing from the client to the server system.

Description

[0001] Cross Reference to Related Applications

[0002] This PCT patent application claims priority to U.S. Patent Application No. 18 / 197,897 (Docket No. 37402-19901), entitled “High Precision Geometry Service for Thin Client Applications,” filed May 16, 2023, and U.S. Patent Application No. 18 / 197,929 (Docket No. 37402-20101), entitled “High Precision Geometry Client for Thin Client Applications,” filed May 16, 2023, each of which is incorporated by reference in its entirety. TECHNICAL FIELD

[0003] The present invention relates generally to systems and methods for efficiently obtaining high precision geometry for graphical objects on thin client applications, such as applications running on browsers or handheld devices. BACKGROUND

[0004] Modern client applications running in browsers or inside native applications on mobile devices can display geometry shapes either by having a service hosted on a server provide render-ready optimized graphics, or by directly streaming tessellated geometry from the server. Tessellated geometry is an approximate representation using triangles (also known as faces) or lines. The number of triangles or lines depends on the stroke tolerance or the level of detail of the geometry tessellation. However, client applications also need to be able to obtain and display high precision geometry, i.e., the exact edge or surface geometry associated with a graphical object, and allow the application user to identify unique locations on this geometry. Neither the render-ready geometry nor the tessellated geometry has the necessary information or precision to be used or converted into high precision geometry. Furthermore, client applications running on desktops have attempted to obtain high precision geometry directly from geometry persisted in a database. One drawback of this approach is that it requires significant logic processing and computational resources on the client. This is perhaps feasible on high performance desktop devices with available resources, but for resource-starved clients, such as those running inside browsers or on mobile devices, this heavy demand on resources makes it difficult to implement. SUMMARY

[0005] According to one embodiment, a high-precision geometry system and method includes a high-precision geometry server and a client device, wherein the client device identifies a graphical object requiring high-precision geometry for rendering on a display of the client device; the client device determines a moniker identifier for the graphical object; the client device transmits a client request for high-precision geometry to the high-precision geometry server via an application programming interface (API), the client request including the moniker identifier; the high-precision geometry server receives the client request for high-precision geometry from the client device via the API, the client request including the moniker identifier; the high-precision geometry... The high-precision geometry server retrieves raw geometry data from persistent storage based on the tag identifier; the high-precision geometry server generates high-precision geometry data from the raw geometry data; the high-precision geometry server formats the high-precision geometry data into a formatted message for use by the client device; the high-precision geometry server transmits the message to the client device via the application programming interface (API); the client device receives the message containing the formatted high-precision geometry data of the graphic object from the high-precision geometry server via the API; the client device converts the high-precision geometry data into subdivision geometry data; and the client device renders the subdivision geometry data on its display.

[0006] In various alternative implementations, the application programming interface (API) may be a REST API. The client request may be an HTTP request. Generating high-precision geometry data from the raw geometry data may involve sending the raw geometry data to an instance of a math processor. The high-precision geometry server may be configured to run multiple instances of the math processor. The message formatted for rendering by the client device may be a JSON message. The high-precision geometry data may include projections. The client request may also include options required for the high-precision geometry. The options may include at least one of edge geometry type, surface geometry type, full geometry type, edge keypoints, or surface keypoints. The client device may include a high-precision geometry client configured to run in a thin client application.

[0007] According to another embodiment, a high-precision geometry server system, method, and computer program product implements a high-precision geometry service that performs a process including the following steps: receiving a client request for high-precision geometry from a client device via an application programming interface (API), the client request including a tag identifier; retrieving raw geometry data from persistent storage based on the tag identifier; generating high-precision geometry data from the raw geometry data; formatting the high-precision geometry data into a formatted message for use by the client device; and transmitting the message to the client device via the API.

[0008] In various alternative implementations, the application programming interface (API) may be a REST API. The client request may be an HTTP request. Generating high-precision geometric data from the raw geometric data may involve sending the raw geometric data to an instance of a mathematical processor. The high-precision geometry service may be configured to run multiple instances of the mathematical processor. The message formatted for rendering by the client device may be a JSON message. The high-precision geometric data may include projections or other high-precision graphics operations.

[0009] According to another embodiment, a high-precision geometry client system, method, and computer program product implements a high-precision geometry service that performs a process including the following steps: identifying a graphic object requiring high-precision geometry for rendering on a display of a client device; determining a marker identifier for the graphic object; transmitting a client request for high-precision geometry to a high-precision geometry server via an application programming interface (API), the client request including the marker identifier; receiving a message containing formatted high-precision geometry data of the graphic object from the high-precision geometry server via the API; converting the high-precision geometry data into subdivision geometry data; and rendering the subdivision geometry data on the display of the client device.

[0010] In various alternative implementations, the application programming interface (API) may be a REST API. The client request may be an HTTP request. The message may be a JSON message. The high-precision geometry data may include projections or other high-precision graphics operations. The client request may also include options required for the high-precision geometry. The high-precision geometry client may be configured to run in a thin-client application.

[0011] Other implementation methods may be disclosed and protected. Attached Figure Description

[0012] Those skilled in the art will more fully understand the advantages of various embodiments of the invention from the following “Description of Exemplary Embodiments”, which is discussed in conjunction with the accompanying drawings outlined below.

[0013] Figure 1 This is a schematic diagram illustrating an exemplary system implementation conforming to this disclosure.

[0014] Figure 2 This is a schematic block diagram illustrating at least one embodiment of a client device configured as a mobile device in accordance with the present disclosure.

[0015] Figure 3 This is a schematic block diagram illustrating relevant components of a server system according to certain implementations.

[0016] Figure 4 This is a schematic block diagram showing the relevant components of the high-precision geometry service in more detail.

[0017] Figure 5 This is a schematic diagram of message flow supported by high-precision geometry according to certain implementation methods.

[0018] It should be noted that the foregoing figures and the elements depicted therein are not necessarily drawn to a uniform scale or any scale. Like elements are indicated by like numerals unless the context otherwise requires. The figures are for illustrative purposes only and are not intended to limit the scope of the subject matter invention described herein. Detailed Implementation

[0019] Definitions. As used in this specification and the appended claims, the following terms shall have indicative meanings unless the context requires otherwise.

[0020] A “group” includes one or more members, even if the description of the group is presented in plural form (e.g., a group X may include one or more Xs).

[0021] Some implementations typically involve systems and methods for efficiently acquiring high-precision geometry for graphical objects on thin client applications, such as those running on browsers or handheld devices. Specifically, a high-precision geometry client (PGC) running on a client device sends a request to a corresponding high-precision geometry service (PGS) running on a server system to acquire high-precision geometric primitives for rendering on the client device, thereby offloading processor-intensive high-precision geometry processing from the client to the server system.

[0022] Figure 1An embodiment of an exemplary system 10 conforming to this disclosure is illustrated. As shown, system 10 includes one or more servers 12, which may run, for example, on an enterprise computing system 14 and / or an external computing system 22 (e.g., a cloud-based computing system). For convenience, one or more servers 12 running on one or more computing systems 14, 22 may be collectively referred to as server system 12. It should be noted that the term "server" herein refers broadly to any computing device or system capable of performing the various operations discussed herein, and is not limited to, for example, physical or virtual server computers.

[0023] System 10 also includes one or more client computing devices 16(a)-16(n), which for convenience may be individually referred to as client device 16 or collectively as client device 16. Each client device 16(a)-16(n) is typically associated with a corresponding user 15(a)-15(n), which for convenience may be individually referred to as user 15 or collectively as user 15. However, it should be noted that some client devices 16 may not be related to a specific user 15 (e.g., client device 16 may operate autonomously or may be associated with a non-user entity such as a company or vehicle). In the current context, user 15 may include administrators, clients, developers, or clients for whom services are provided by server system 12. User 15 may also include a specific individual to whom the service is addressed.

[0024] Server system 12 is configured to communicate and share data with one or more user client devices 16 via network 18, and conversely, client devices 16 are configured to communicate and share data with server system 12 via network 18. This may include data input by user 15, data from various applications running on client devices 16, and data generated by client devices 16 themselves (e.g., location / GPS data). Alternatively, client devices 16 may be configured to communicate with each other via network 18 and / or other networks (e.g., a particular client device may communicate with server system 12 via network 18 but with another client device via a different network).

[0025] Network 18 may be or include any data-carrying network. Non-limiting examples of suitable networks that may be used in whole or in part as network 18 include private or non-private local area networks (LANs), personal area networks (PANs), storage area networks (SANs), backbone networks, global area networks (GANs), wide area networks (WANs), metropolitan area networks (MANs), virtual private networks (VPNs), or any collection of such communication networks, such as intranets, extranets, or the Internet (i.e., a globally interconnected network system running various applications or services, including the World Wide Web). User mobile device 16 typically communicates with server system 12 via a wireless communication system, which may include any suitable wireless communication technology. Non-limiting examples of suitable wireless communication technologies include various cellular-based data communication technologies (e.g., 2G, 3G, 4G, LTE, 5G, GSM, etc.), Wi-Fi wireless data communication, wireless LAN communication technologies (e.g., 802.11), Bluetooth wireless data communication, near field communication (NFC) wireless communication, other networks or protocols capable of carrying data, and combinations thereof. In some implementations, network 18 is selected from the Internet, at least one wireless network, at least one cellular communication network, and combinations thereof. Therefore, network 18 may include any number of additional devices, such as additional computers, routers, and switches, to facilitate communication. In some embodiments, network 18 may be or include a single network, while in other embodiments, network 18 may be or include a collection of networks.

[0026] Server system 12 is configured to communicate and share data with client devices 16 associated with one or more users 15. Therefore, client devices 16 can be specifically implemented as any type of device for communicating with server system 12 and / or other client devices via network 18. For example, at least one client device can be specifically implemented as (but not limited to) a computer, desktop computer, personal computer (PC), tablet computer, laptop computer, notebook computer, mobile computing device, smartphone, cellular phone, handheld device, messaging device, workstation, distributed computing system, multiprocessor system, processor-based system, and / or any other computing device configured to store and access data, and / or execute software and related applications conforming to this disclosure.

[0027] Figure 2This is a block diagram illustrating at least one embodiment of a client device 16 configured as a mobile device according to the present disclosure, but it should be noted that the embodiments are not limited to mobile client devices. The mobile device 16 typically includes a computing system 100. As shown, the computing system 100 may include one or more processors 102, which may include, for example, at least one main processor (e.g., a microprocessor, microcontroller, central processing unit, etc.) and optionally at least one graphics processing unit (GPU) for performing various graphics-specific operations, including, for example, generating subdivided graphics for display on display unit 108 (however, in some embodiments, the main processor may include a GPU and / or an extended instruction set of graphics instructions, or may otherwise perform graphics-specific operations, e.g., in software). For convenience, the one or more processors are collectively referred to herein as "processor 102". Processor 102 is operatively connected to communication infrastructure 104 (e.g., a communication bus, crossbar switch, or network). Processor 102 may be specifically implemented as any type of processor capable of performing the functions described herein. For example, a processor may be specifically implemented as a single-core or multi-core processor, a digital signal processor, a microcontroller, or other processor or processing / control circuitry.

[0028] The computing system 100 also includes a display interface 106 that forwards graphics, text, sound, and other data from the communication infrastructure 104 (or from a data buffer not shown) for display on the display unit 108. The computing system also includes an input device 110. This input device 110 may include one or more devices for interacting with the mobile device 16, such as a keyboard, microphone, camera, and other input components such as motion sensors. In one embodiment, the display unit 108 may include a touch-sensitive display (also referred to as a “touchscreen”), in addition to or replacing a physical button keyboard, etc. Touchscreens typically display graphics and text and provide a user interface (e.g., but not limited to, a graphical user interface (GUI)) through which a user interacts with the mobile device 16, such as accessing and interacting with applications running on the device 16.

[0029] The computing system 100 also includes main memory 112, such as random access memory (RAM), and may also include auxiliary memory 114. Main memory 112 and auxiliary memory 114 can be specifically implemented as any type of device configured for short-term or long-term data storage, such as memory devices and circuitry, memory cards, hard disk drives, solid-state drives, or other data storage devices. Similarly, memories 112 and 114 can be specifically implemented as any type of volatile or non-volatile memory or data storage device capable of performing the functions described herein.

[0030] In an exemplary embodiment, mobile device 16 may store one or more applications, databases, media, and / or other information in main memory and / or secondary memory 112, 114. Secondary memory 114 may include, for example, hard disk drive 116 and / or removable storage drive 118, representing a floppy disk drive, magnetic tape drive, optical disk drive, etc. Removable storage drive 118 reads and / or writes to removable storage unit 120 in any known manner. Removable storage unit 120 may represent a floppy disk, magnetic tape, optical disk, etc., read and written by removable storage drive 118. It is understood that removable storage unit 120 includes a computer-usable storage medium having computer software and / or data stored therein.

[0031] In an alternative implementation, auxiliary memory 114 may include other similar devices for allowing computer programs or other instructions to be loaded into computing system 100. Such devices may include, for example, removable storage unit 124 and interface 122. Examples of such devices may include program cassettes and cassette interfaces (as in video game devices), removable memory chips (such as erasable programmable read-only memory (EPROM) or programmable read-only memory (PROM)) and associated sockets, as well as other removable storage units 124 and interfaces 122 that allow software and data to be transferred from removable storage unit 124 to computing system 100.

[0032] The computing system 100 also includes one or more applications 126 stored directly thereon. The applications 126 may include any number of different software applications, each configured to perform a specific task.

[0033] The computing system 100 also includes a communication interface 128. The communication interface 128 can be specifically implemented as any communication circuit, device, or combination thereof capable of enabling communication between the mobile device 16 and external devices (other mobile devices 16, cloud-based service 14, and external computing system / server 22). The communication interface 128 can be configured to use any one or more communication technologies and related protocols, as described above, to achieve such communication. For example, the communication interface 128 can be configured to communicate and exchange data with the server 12, the external computing system / server 22, and / or another mobile device 16 via a wireless transmission protocol, including but not limited to Bluetooth communication, infrared communication, near field communication (NFC), radio frequency identification (RFID) communication, cellular network communication, IEEE 802.11 transmission protocol standard versions, and combinations thereof. Examples of the communication interface 128 may include a modem, a network interface (e.g., an Ethernet card), a communication port, a PCMCIA slot and card, wireless communication circuitry, etc.

[0034] Computer programs (also referred to as computer control logic) may be stored in a local database on main memory 112 and / or auxiliary memory 114 or mobile device 16. Computer programs may also be received via communication interface 128. Such computer programs, when executed, enable computing system 100 to perform the features of the invention, as discussed herein. Specifically, computer programs (including application program 126), when executed, enable processor 102 to perform the features of the invention. Therefore, such computer programs represent the controller of computer system 100.

[0035] In one embodiment, the invention is primarily implemented in software, which may be stored in a computer program product and loaded into the computing system 100 using a removable storage drive 118, a hard disk drive 116, or a communication interface 128. When executed by processor 102, the control logic (software) causes processor 102 to perform the functions of the invention described herein. In another embodiment, the invention may be primarily implemented in hardware, for example using hardware components such as application-specific integrated circuits (ASICs). The implementation of the hardware state machine performing the functions will be readily apparent to those skilled in the art. In yet another embodiment, the invention may be implemented using a combination of hardware and software.

[0036] To provide high-precision geometry on client device 16, some implementations will include new components running on server system 12 and client device 16. For convenience, the new component running on server system is referred to herein as High-Precision Geometry Service (PGS), and the new component running on client device 16 is referred to herein as High-Precision Geometry Client (PGC).

[0037] like Figure 3 As illustrated, in some exemplary embodiments, PGS preferably includes two distinct microservices that are preferably (but not required) deployed separately: a high-precision geometry service API 26 (which could be a Web API) and a high-precision geometry backend 28. Furthermore, this separation, while not mandatory, allows these services to scale horizontally individually based on server load, thereby optimizing server resources. In some exemplary embodiments, the high-precision geometry service API 26 is implemented as a REST API based on the OData standard, but other implementations are also possible. The high-precision geometry service API 26 communicates with the high-precision geometry backend 28, for example, via gRPC messages. Thus, for example, the high-precision geometry backend 28 may include a gRPC service that listens for and responds to requests from the high-precision geometry service API 26.

[0038] like Figure 4As illustrated, in some exemplary embodiments, the PGS includes additional components such as a math processor 32 and a data access layer 34. The data access layer (DAL) 34 is configured to read persistent geometry data 36 from persistent storage 30. In some exemplary embodiments, the client device 16 provides an identifier (e.g., a tag ID or other identifier) ​​for the requested geometry data 36, ​​and the data access layer 34 retrieves the geometry data 36 from persistent storage 30 based on this identifier. The raw geometry data 36 is provided to the math processor 32, which is configured to convert the raw geometry data 36 into high-precision geometry primitives. It should be noted that multiple instances of the math processor 32 can be executed within the server system 12, for example, using multiple cloud containers. These high-precision geometry primitives are then converted into an optimal format (e.g., JSON format) that can be used / rendered by the client device 16. Because the PGS is configured to handle multiple high-precision geometry requests simultaneously, the high-precision geometry backend 28 can store workflow data 38, for example, to correlate client requests with raw and high-precision geometry data, thereby supporting asynchronous APIs.

[0039] More specifically, such as Figure 5 As illustrated, in some exemplary embodiments, client device 16 sends an HTTP request containing a tag ID to High-Precision Geometry Service API 26. High-Precision Geometry Service API 26 sends a corresponding gRPC request to High-Precision Geometry Backend 28. High-Precision Geometry Backend 28 requests Data Access Layer 34 to retrieve raw geometry data based on the tag ID from client device 16. Data Access Layer 34 interacts with persistent storage device 30 to read raw geometry data 36 and returns it to High-Precision Geometry Backend 28. High-Precision Geometry Backend 28 then sends the raw geometry data to Math Processor 32, which generates high-precision geometry primitives and returns them to High-Precision Geometry Backend 28. High-Precision Geometry Backend 28 packages the high-precision geometry primitives and sends them to client device 16 via High-Precision Geometry Service API 26, whereby client device 16 can render or otherwise process the high-precision geometry primitives (e.g., convert the high-precision geometry into subdivision geometry for rendering on the screen).

[0040] Therefore, in addition to this, PGC will typically be configured to perform the following operations:

[0041] 1. Retrieve the tag of the graphic object that requests its high-precision geometry.

[0042] 2. Prepare an HTTP request with the necessary options for marking and high-precision geometry.

[0043] 3. Convert the high-precision geometry obtained in the response into subdivision geometry and render it on the screen.

[0044] 4. Given user input, obtain the object's unique location in precise geometry.

[0045] In addition, PGS will typically be configured to perform the following operations:

[0046] 1. Receive requests (e.g., HTTP requests) from clients via the High Precision Geometry Service API.

[0047] 2. Read the raw geometry of a given graphic object from persistent storage.

[0048] 3. Generate high-precision geometric primitives from the original geometry.

[0049] 4. Convert high-precision geometry into an optimal format that can be used by the client.

[0050] 5. Prepare a response containing high-precision geometric data and transmit the response to the client device 16 via the High-Precision Geometry Service API.

[0051] Therefore, services deployed on servers prepare high-precision geometry, enabling client components to access this geometry without requiring significant resources on the client device. These services can further scale independently of the client, allowing them to be used in thin-client applications to deliver high-performance services on thin-client devices such as browsers and mobile apps.

[0052] It should be noted that PGC and PGS can be configured to handle more complex, high-precision geometric operations, such as, but not limited to, forming 2D projections or slices of 3D geometry, forming 3D geometry from 2D data, rotating / translating / flipping geometric data, texture mapping, adding augmented reality elements to the geometry display, generating B-spline surfaces, manipulating geometry such as cones, spheres, and tori.

[0053] The following are example REST APIs exposed on PGS and invoked by PGC according to various implementation methods.

[0054] 1. / Geometry / FetchEdgeExtent: Provides the ability to determine parameters describing the distance a 3D point extends along an edge, given the object's id, the names of the edges contained on the object, and the 3D point.

[0055] Request Text

[0056] {

[0057] edgeMonikers: [

[0058] string ]

[0060] renderIds: [

[0061] integer($int64) ]

[0063] x: [

[0064] number($double) ]

[0066] y: [

[0067] number($double) ]

[0069] z: [

[0070] number($double) ]

[0072] }

[0073] Response Text

[0074] {

[0075] edgeMoniker: string

[0076] extent: string

[0077] }

[0078] 2. / Geometry / FetchEdgePointFromExtent: Provides the ability to determine a 3D point located on an edge at a given distance, given the rendering ID of the object, the name of the edge contained on the object, and extension parameters describing the distance along the edge.

[0079] Request text

[0080] {

[0081] edgeMonikers: [

[0082] string ]

[0084] extent: [

[0085] number($double) ]

[0087] renderIds: [

[0088] integer($int64) ]

[0090] }

[0091] Response text

[0092] {

[0093] moniker: string

[0094] renderId: integer($int64)

[0095] stream: string

[0096] }

[0097] 3. / Geometry / MonikerLookup: Provides the ability to return a combination of the edges, surfaces, or key points of an object based on the markers of the given object and a set of markers.

[0098] Request text

[0099] monikers: [

[0100] string ]

[0102] flags: [

[0103] integer($int64) ]

[0105] Response text

[0106] {

[0107] moniker: string

[0108] renderId: integer($int64)

[0109] stream: string

[0110] }

[0111] 4. / Geometry / RenderIdLookup: Provides the ability to obtain a combination of the edges, surfaces, or key points of an object based on the object's render ID and a set of flags.

[0112] Request text

[0113] {

[0114] renderIds: [

[0115] integer($int64) ]

[0117] flags: [

[0118] integer($int64) ]

[0120] }

[0121] Response text

[0122] {

[0123] moniker: string

[0124] renderId: integer($int64)

[0125] stream: string

[0126] }

[0127] The `flags` parameter specifies a set of high-precision geometry operations to be performed and returned to the PGC. In some implementations, `flags` are individual bits that can be set and checked using bitwise operators, although this set of high-precision geometry operations can be specified in other ways, such as using strings, descriptors, objects, etc. In some implementations, this set of high-precision geometry operation flags is defined as follows (where "0x" represents a hexadecimal value):

[0128] 0x01 - If set, returns the edge geometry type

[0129] 0x02 - If set, returns the surface geometry type.

[0130] 0x04 - If set, returns the complete geometry type.

[0131] 0x08 - If set, return edge key points

[0132] 0x10 - If set, returns surface key points.

[0133] 0x20 - If set, returns all created keypoints.

[0134] Unused bits are reserved, for example, to allow for the addition of further high-precision geometric operations or other functions in the future.

[0135] Therefore, for example, in some implementations, these six flag bits can be encoded as follows:

[0136]

[0137] To perform geometric processing, PGS can access a mathematical function library (mathematical kernel), for example, through various C++ APIs. Below are some geometric processing operations that PGS can perform using mathematical kernel functions in various implementations:

[0138] 1. Create a semi-infinite (drill line ray) line using two points, with the viewpoint as point one and a screen point as the other, for example, projecting the points onto the surface or edge of an object.

[0139] 2. The intersection of the geometric surface or edge with the drill line.

[0140] 3. Find the minimum distance between multiple geometric surfaces.

[0141] 4. Find the minimum distance between the borehole line and the curve (b-spline curve, circular arc, ellipse, straight line).

[0142] 5. Find the minimum distance between multiple curves.

[0143] 6. Find the intersection point of the borehole line and the curve.

[0144] 7. Use curve parameters to find high-precision points along the curve.

[0145] 8. Use geometric parameters to find high-precision points on a geometric surface.

[0146] Various embodiments of the present invention can be implemented, at least in part, in any conventional computer programming language. For example, some embodiments can be implemented using a procedural programming language (e.g., "C") or an object-oriented programming language (e.g., "C++"). Other embodiments of the present invention can be implemented as pre-configured standalone hardware elements and / or pre-programmed hardware elements (e.g., application-specific integrated circuits, FPGAs, and digital signal processors) or other related components.

[0147] In alternative implementations, the disclosed apparatus and methods (e.g., as described in any of the flowcharts or logic flows above) can be implemented as a computer program product for a computer system. Such implementation may include a set of computer instructions fixed on a tangible, non-transitory medium (e.g., a computer-readable medium such as a disk, CD-ROM, ROM, or fixed disk). This set of computer instructions may specifically implement all or part of the system functionality previously described herein.

[0148] Those skilled in the art will understand that such computer instructions can be written in a variety of programming languages ​​and used in a variety of computer architectures or operating systems. Furthermore, such instructions can be stored in any memory device, such as tangible non-transient semiconductor, magnetic, optical, or other memory devices, and can be transmitted using any communication technology (e.g., optical, infrared, radio frequency / microwave, or other transmission technologies) through any suitable medium (e.g., wired media (e.g., wires, coaxial cables, fiber optic cables, etc.) or wireless media (e.g., through air or space)).

[0149] Furthermore, this computer program product can be distributed in various ways, such as as a removable medium with accompanying printed or electronic documentation (e.g., laminated software), pre-installed on a computer system (e.g., on system ROM or a fixed disk), or distributed from a server or electronic bulletin board via a network (e.g., the Internet or the World Wide Web). In practice, some implementations can be implemented in a Software as a Service (“SaaS”) or cloud computing model. Of course, some embodiments of the invention can be implemented as a combination of software (e.g., a computer program product) and hardware. Other embodiments of the invention are implemented entirely in hardware or entirely in software.

[0150] The computer program logic that implements all or part of the functionality described above can execute at different times on a single processor (e.g., concurrently), or it can execute at the same or different times on multiple processors, and can run under a single operating system process / thread or different operating system processes / threads. Therefore, the term "computer process" generally refers to the execution of a set of computer program instructions, regardless of whether different computer processes execute on the same or different processors, and regardless of whether different computer processes run under the same or different operating system processes / threads. Software systems can be implemented using various architectures, such as monolithic architectures or microservice architectures.

[0151] Importantly, it should be noted that embodiments of the present invention can employ conventional components such as conventional computers (e.g., off-the-shelf PCs, mainframes, microprocessors), conventional programmable logic devices (e.g., off-the-shelf FPGAs or PLDs), or conventional hardware components (e.g., off-the-shelf ASICs or discrete hardware components). When these components are programmed or configured to perform the non-conventional methods described herein, non-conventional devices or systems are produced. Therefore, the invention described herein has no conventionality, because even when implementing embodiments using conventional components, the resulting devices and systems (e.g., EAM system 28, overlay module 32, workflow module 34, smartphone applications, etc.) are necessarily non-conventional, since conventional components themselves do not perform the described non-conventional functions without special programming or configuration.

[0152] The activities described and claimed herein provide technical solutions to problems arising in the technical field. These solutions, as a whole, are not known, conventional, or traditional in the art, and in any case, provide practical applications for transforming and improving computers and computer routing systems.

[0153] Although various embodiments of the invention have been described and illustrated herein, those skilled in the art will readily envision numerous other means and / or structures for performing the described functions and / or obtaining the described results and / or one or more of the described advantages, and each of such variations and / or modifications is considered to be within the scope of embodiments of the invention. More generally, those skilled in the art will readily understand that all parameters, dimensions, materials, and configurations described herein are exemplary, and actual parameters, dimensions, materials, and / or configurations will depend on the specific application for which the teachings of the invention are applied. Those skilled in the art will recognize or be able to determine many equivalents of the specific embodiments of the invention described herein using only experiments not exceeding conventional methods. Therefore, it should be understood that the foregoing embodiments are presented as examples only, and that embodiments of the invention may be practiced in ways other than those specifically described and claimed within the scope of the appended claims and their equivalents. Embodiments of the invention are directed to each individual feature, system, article, material, kit, and / or method described herein. Furthermore, any combination of two or more such features, systems, articles, materials, kits, and / or methods, provided that such features, systems, articles, materials, kits, and / or methods do not contradict each other, is included within the scope of the invention.

[0154] Various inventive concepts can be embodied as one or more methods, examples of which have been provided. The steps performed as part of a method can be ordered in any suitable manner. Thus, implementations in which steps are performed in a different order than those shown can be constructed, which may include performing certain steps simultaneously, even if they are shown as sequential steps in the exemplary implementation.

[0155] All definitions (as defined and used herein) should be understood to take precedence over dictionary definitions, definitions in incorporated documents by reference, and / or the general meaning of the defined terms.

[0156] When the indefinite articles “a” and “an” are used in this specification and claims, they shall be understood to mean “at least one” unless expressly stated otherwise.

[0157] When used in this specification and claims, the phrase “and / or” should be understood to mean “one or both of the two,” that is, in some cases an element present in conjunction, and in others an element present in disjunction. Multiple elements listed with “and / or” should be interpreted in the same way, that is, “one or more” of the elements so connected. Other elements may optionally be present, whether or not they are related to those specifically identified by the “and / or” clause. Thus, as a non-limiting example, a reference to “A and / or B,” when used in conjunction with open-ended language such as “comprising,” may, in one embodiment, refer to only A (optionally including elements other than B); in another embodiment, refer to only B (optionally including elements other than A); in yet another embodiment, refer to both A and B (optionally including other elements); and so on.

[0158] As used in this specification and claims, “or” should be understood to have the same meaning as “and / or” as defined above. For example, when separating items in a list, “or” or “and / or” should be interpreted as inclusive (i.e., non-exclusive), meaning it includes at least one of the listed elements and, optionally, additional items not listed. Only terms that explicitly indicate the opposite meaning, such as “only one” or “exactly one,” or “consisting of” as used in the claims, mean exactly one of a plurality of or one of the listed elements. Generally, the term “or” as used herein should only be interpreted as indicating an exclusive alternative (i.e., “either / or”) when modified by exclusive terms such as “any,” “one of,” “only one,” or “exactly one.” When used in the claims, “substantially constitutes” should have its usual meaning as used in the field of patent law.

[0159] As used herein in the specification and claims, the phrase “at least one” when referring to a list of one or more elements should be understood to mean at least one element selected from any one or more elements in the list, but does not necessarily include every single element specifically listed in the list and at least one of each element, and does not exclude any combination of elements in the list. This definition also allows for the optional presence of elements other than those specifically identified in the list referred to by the phrase “at least one,” whether or not they are related to those specifically identified elements. Thus, as a non-limiting example, “at least one of A and B” (or, equivalently, “at least one of A or B,” or, equivalently, “at least one of A and / or B”) could mean, in one embodiment, at least one (optionally including more than one) A, with no B (and optionally including elements other than B); in another embodiment, at least one (optionally including more than one) B, with no A (and optionally including elements other than A); in yet another embodiment, at least one (optionally including more than one) A, and at least one (optionally including more than one) B (and optionally including other elements); and so on.

[0160] As used herein in the specification and claims, all transitional phrases such as “comprising,” “including,” “carrying,” “having,” “containing,” “involving,” “holding,” “composed of,” etc., shall be understood as open-ended, i.e., meaning including but not limited to. Only the transitional phrases “consisting of” and “substantially composed of” shall be closed or semi-closed transitional phrases, respectively, as described in Section 2111.03 of the U.S. Patent Examination Procedure Manual.

[0161] While the foregoing discussion has disclosed various exemplary embodiments of the invention, it should be understood that various modifications can be made by those skilled in the art to achieve certain advantages of the invention without departing from its true scope. Any reference to "the invention" is intended to refer to exemplary embodiments of the invention and should not be construed as referring to all embodiments of the invention unless the context requires otherwise. The described embodiments are to be considered illustrative rather than restrictive in all respects.

Claims

1. A high-precision geometry system, the high-precision geometry system comprising a high-precision geometry server and client devices, wherein: The client device identifies graphical objects that require high-precision geometry for rendering on the client device's display. The client device determines a tag identifier for the graphical object; The client device transmits a client request for high-precision geometry to the high-precision geometry server via an application programming interface, the client request including the tag identifier; The high-precision geometry server receives the client request for high-precision geometry from the client device via the application programming interface, the client request including the tag identifier; The high-precision geometry server retrieves the original geometric data from the persistent storage device based on the tag identifier; The high-precision geometry server generates high-precision geometry data from the original geometry data; The high-precision geometry server formats the high-precision geometry data into a formatted message for use by the client device; The high-precision geometry server transmits the message to the client device via the application programming interface; The client device receives the message containing formatted high-precision geometric data of the graphic object from the high-precision geometry server via the application programming interface; The client device converts the high-precision geometric data into subdivided geometric data; and The client device renders the subdivision geometry data on its display.

2. The system according to claim 1, wherein, The application programming interface (API) is a REST API.

3. The system according to claim 1, wherein, The client request is an HTTP request.

4. The system according to claim 1, wherein, Generating high-precision geometric data from the raw geometric data includes an instance of sending the raw geometric data to a mathematical processor.

5. The system according to claim 4, wherein, The high-precision geometry server is configured to run multiple instances of the mathematical processors.

6. The system according to claim 1, wherein, The message, formatted for rendering by the client device, is a JSON message.

7. The system according to claim 1, wherein, The high-precision geometric data includes projections.

8. The system according to claim 1, wherein, The client request also includes options required for the high-precision geometry.

9. The system according to claim 8, wherein, The options include at least one of edge geometry type, surface geometry type, full geometry type, edge keypoint, or surface keypoint.

10. The system according to claim 1, wherein, The client device includes a high-precision geometry client configured to run in a thin client application.

11. A high-precision geometric method, the high-precision geometric method comprising: The client device identifies graphical objects that require high-precision geometry for rendering on the client device's display; The client device determines the tag identifier for the graphical object; The client device transmits a client request for high-precision geometry to the high-precision geometry server via an application programming interface, the client request including the tag identifier; The high-precision geometry server receives the client request for high-precision geometry from the client device via the application programming interface, the client request including the tag identifier; The high-precision geometry server retrieves the original geometric data from the persistent storage device based on the tag identifier; The high-precision geometry server generates high-precision geometric data from the original geometric data; The high-precision geometry server formats the high-precision geometry data into a formatted message for use by the client device. The message is transmitted from the high-precision geometry server to the client device via the application programming interface; The client device receives, via the application programming interface, the message containing formatted high-precision geometric data of the graphic object from the high-precision geometry server. The client device converts the high-precision geometric data into subdivided geometric data; as well as The client device renders the subdivided geometry data on its display.

12. The method according to claim 11, wherein, The application programming interface (API) is a REST API.

13. The method according to claim 11, wherein, The client request is an HTTP request.

14. The method according to claim 11, wherein, Generating high-precision geometric data from the raw geometric data includes an instance of sending the raw geometric data to a mathematical processor.

15. The method according to claim 14, wherein, The high-precision geometry server is configured to run multiple instances of the mathematical processors.

16. The method according to claim 11, wherein, The message, formatted for rendering by the client device, is a JSON message.

17. The method according to claim 11, wherein, The high-precision geometric data includes projections.

18. The method according to claim 11, wherein, The client request also includes options required for the high-precision geometry.

19. The method according to claim 18, wherein, The options include at least one of edge geometry type, surface geometry type, full geometry type, edge keypoint, or surface keypoint.

20. The method according to claim 11, wherein, The client device includes a high-precision geometry client configured to run in a thin client application.

21. A high-precision geometry server system, the high-precision geometry server system comprising: At least one processor, the at least one processor being coupled to at least one memory, the at least one memory containing instructions that, when executed by the at least one processor, cause the system to implement a high-precision geometry service, wherein the high-precision geometry service is configured to perform a process including the following steps: Receive client requests for high-precision geometry from a client device via an application programming interface, the client requests including a tag identifier; Retrieve the original geometric data from the persistent storage device based on the tag identifier; High-precision geometric data is generated from the original geometric data; Formatting the high-precision geometric data into a formatted message for use by the client device; and The message is transmitted to the client device via the application programming interface.

22. The system according to claim 21, wherein, The application programming interface (API) is a REST API.

23. The system according to claim 21, wherein, The client request is an HTTP request.

24. The system according to claim 21, wherein, Generating high-precision geometric data from the raw geometric data includes an instance of sending the raw geometric data to a mathematical processor.

25. The system according to claim 24, wherein, The high-precision geometry service is configured to run multiple instances of the mathematical processor.

26. The system according to claim 21, wherein, The high-precision geometry service is configured to apply mathematical kernel functions to the original geometry data to generate the high-precision geometry data.

27. The system according to claim 21, wherein, The message, formatted for rendering by the client device, is a JSON message.

28. The system according to claim 21, wherein, The high-precision geometric data includes projections.

29. The system according to claim 21, wherein, The client request also includes options required for the high-precision geometry.

30. The system according to claim 29, wherein, The options include at least one of edge geometry type, surface geometry type, full geometry type, edge keypoint, or surface keypoint.

31. A high-precision geometry server method, the high-precision geometry server method comprising: A high-precision geometry service running on a server system receives client requests for high-precision geometry from a client device via an application programming interface, the client requests including a tag identifier; The high-precision geometry service running on the server system retrieves the original geometry data from persistent storage based on the tag identifier; High-precision geometric data is generated from the original geometric data by the high-precision geometry service running on the server system; The high-precision geometry service running on the server system formats the high-precision geometry data into a formatted message for use by the client device; as well as The high-precision geometry service running on the server system transmits the message to the client device via the application programming interface.

32. The method according to claim 31, wherein, The application programming interface (API) is a REST API.

33. The method according to claim 31, wherein, The client request is an HTTP request.

34. The method according to claim 31, wherein, Generating high-precision geometric data from the raw geometric data includes an instance of sending the raw geometric data to a mathematical processor.

35. The method according to claim 34, wherein, The high-precision geometry service is configured to run multiple instances of the mathematical processor.

36. The method according to claim 31, wherein, The high-precision geometry service is configured to apply mathematical kernel functions to the original geometry data to generate the high-precision geometry data.

37. The method according to claim 31, wherein, The message, formatted for rendering by the client device, is a JSON message.

38. The method according to claim 31, wherein, The high-precision geometric data includes projections.

39. The method according to claim 31, wherein, The client request also includes options required for the high-precision geometry.

40. The method according to claim 39, wherein, The options include at least one of edge geometry type, surface geometry type, full geometry type, edge keypoint, or surface keypoint.

41. A computer program product comprising at least one tangible, non-transitory, computer-readable storage medium wherein computer program instructions are implemented, which, when executed by one or more processors of a system, cause the system to perform a high-precision geometry server service, wherein... The high-precision geometry service is configured to perform a process including the following steps: Receive client requests for high-precision geometry from a client device via an application programming interface, the client requests including a tag identifier; Retrieve the original geometric data from the persistent storage device based on the tag identifier; High-precision geometric data is generated from the original geometric data; The high-precision geometric data is formatted into a formatted message for use by the client device; as well as The message is transmitted to the client device via the application programming interface.

42. The computer program product according to claim 41, wherein, The application programming interface (API) is a REST API.

43. The computer program product according to claim 41, wherein, The client request is an HTTP request.

44. The computer program product according to claim 41, wherein, Generating high-precision geometric data from the raw geometric data includes an instance of sending the raw geometric data to a mathematical processor.

45. The computer program product according to claim 44, wherein, The high-precision geometry service is configured to run multiple instances of the mathematical processor.

46. ​​The computer program product according to claim 41, wherein, The high-precision geometry service is configured to apply mathematical kernel functions to the original geometry data to generate the high-precision geometry data.

47. The computer program product according to claim 41, wherein, The message, formatted for rendering by the client device, is a JSON message.

48. The computer program product according to claim 41, wherein, The high-precision geometric data includes projections.

49. The computer program product according to claim 41, wherein, The client request also includes options required for the high-precision geometry.

50. The computer program product according to claim 49, wherein, The options include at least one of edge geometry type, surface geometry type, full geometry type, edge keypoint, or surface keypoint.

51. A high-precision geometric client system, the high-precision geometric client system comprising: At least one processor, the at least one processor being coupled to at least one memory, the at least one memory containing instructions that, when executed by the at least one processor, cause the system to implement a high-precision geometry client, wherein the high-precision geometry client is configured to perform a process including the following steps: Identify graphic objects that require high-precision geometry for rendering on the client device's display; Determine the tag identifier for the graphical object; A client request for high-precision geometry is transmitted to the high-precision geometry server via an application programming interface, the client request including the tag identifier; Receive a message containing formatted high-precision geometric data of the graphic object from the high-precision geometry server via the application programming interface; Convert the high-precision geometric data into subdivided geometric data; and The subdivision geometry data is rendered on the display of the client device.

52. The system according to claim 51, wherein, The application programming interface (API) is a REST API.

53. The system according to claim 51, wherein, The client request is an HTTP request.

54. The system according to claim 51, wherein, The message is a JSON message.

55. The system according to claim 51, wherein, The high-precision geometric data includes projections.

56. The system according to claim 51, wherein, The client request also includes options required for the high-precision geometry.

57. The system according to claim 51, wherein, The high-precision geometry client is configured to run in a thin client application.

58. A high-precision geometry client method, the high-precision geometry client method comprising: Identify graphic objects that require high-precision geometry for rendering on the client device's display; Determine the tag identifier for the graphical object; A client request for high-precision geometry is transmitted to the high-precision geometry server via an application programming interface, the client request including the tag identifier; Receive a message containing formatted high-precision geometric data of the graphic object from the high-precision geometry server via the application programming interface; The high-precision geometric data is converted into subdivided geometric data; as well as The subdivision geometry data is rendered on the display of the client device.

59. The method according to claim 58, wherein, The application programming interface (API) is a REST API.

60. The method according to claim 58, wherein, The client request is an HTTP request.

61. The method according to claim 58, wherein, The message is a JSON message.

62. The method according to claim 58, wherein, The high-precision geometric data includes projections.

63. The method according to claim 58, wherein, The client request also includes options required for the high-precision geometry.

64. The method according to claim 58, wherein, The high-precision geometry client is configured to run in a thin client application.

65. A computer program product comprising at least one tangible, non-transitory, computer-readable storage medium wherein computer program instructions are implemented, which, when executed by one or more processors of a system, cause the system to implement a high-precision geometric client, wherein... The high-precision geometry client is configured to perform a process including the following steps: Identify graphic objects that require high-precision geometry for rendering on the client device's display; Determine the tag identifier for the graphical object; A client request for high-precision geometry is transmitted to the high-precision geometry server via an application programming interface, the client request including the tag identifier; Receive a message containing formatted high-precision geometric data of the graphic object from the high-precision geometry server via the application programming interface; The high-precision geometric data is converted into subdivided geometric data; as well as The subdivision geometry data is rendered on the display of the client device.

66. The computer program product according to claim 65, wherein, The application programming interface (API) is a REST API.

67. The computer program product according to claim 65, wherein, The client request is an HTTP request.

68. The computer program product according to claim 65, wherein, The message is a JSON message.

69. The computer program product according to claim 65, wherein, The high-precision geometric data includes projections.

70. The computer program product according to claim 65, wherein, The client request also includes options required for the high-precision geometry.

71. The computer program product according to claim 65, wherein, The high-precision geometry client is configured to run in a thin client application.

Images