Virtual terminal incremental interface rendering system, method and terminal based on isobus standard

Abstract

This invention provides a virtual terminal incremental interface rendering system, method, and terminal based on the ISOBUS standard. It first calculates the new hash value of each attribute based on interface object attribute update data extracted from ISOBUS messages, and compares this new hash value with the corresponding attribute hash value cached by the object cache management module to accurately identify the actual changed attributes. Based on this, it determines the update method and generates an update data packet embedding the current version number. Then, considering the visibility of each interface object, user attention, and update frequency, it calculates the rendering priority, combines the target frame rate and rendering time budget, selects the set of objects to be rendered in the current frame, and performs incremental rendering. This invention achieves efficient incremental updates through hash change detection, differential data packet generation, and intelligent rendering scheduling technologies, effectively reducing data transmission volume, improving frame rate, and reducing latency, demonstrating significant performance advantages and broad application prospects.

Description

Technical Field

[0001] This invention relates to the field of computer technology, and in particular to a virtual terminal incremental interface rendering system, method, and terminal based on the ISOBUS standard. Background Technology

[0002] The human-machine interface for agricultural machinery uses the ISOBUS VT (Virtual Terminal) interface rendering mechanism. However, current ISOBUS VT implementations commonly employ a full update mechanism, which has significant drawbacks. When any attribute of an object changes, all attribute data for that object needs to be retransmitted and processed. This leads to a significant waste of CAN bus bandwidth, because in many cases, only a few attributes of an object change, yet the entire object's data needs to be transmitted. In high-frequency update scenarios, bandwidth quickly becomes saturated, resulting in increased interface response latency, severely impacting the user experience and reducing the efficiency of human-machine interaction in agricultural machinery.

[0003] Even with only minor attribute changes, existing rendering mechanisms require virtual terminals to re-parse, validate, and re-render the entire object. Specifically, this involves parsing the complete object data structure, validating all attributes, recalculating the object's layout and display parameters, and finally clearing and redrawing the entire object area. This series of operations typically results in CPU usage exceeding 60%, with a UI refresh rate of only about 10-15 fps. In complex UI scenarios, noticeable stuttering occurs, significantly impacting the smoothness and real-time performance of human-machine interaction in agricultural machinery.

[0004] Furthermore, the existing system has shortcomings in visibility awareness, failing to distinguish between visible and invisible objects and rendering all objects indiscriminately. Specifically, objects off-screen are rendered, occluded objects consume rendering resources, and inactive objects are continuously updated. This results in numerous invalid rendering operations, significant resource waste, and delayed rendering of visible areas. Simultaneously, the system lacks an object caching mechanism; object data is re-parsed from messages with each update. Without effective caching and version management, problems arise such as repeated parsing of the same object data, difficulty in quickly determining whether data has truly changed, and difficulty in tracking and managing object states. This leads to redundant parsing overhead, inability to achieve true incremental updates, and difficulties in debugging and troubleshooting. Summary of the Invention

[0005] In view of the shortcomings of the prior art described above, the purpose of this invention is to provide a virtual terminal incremental interface rendering system, method and terminal based on the ISOBUS standard, to solve the technical problems of existing ISOBUS VT technology, such as bandwidth waste, response latency, high resource consumption and difficulty in achieving incremental updates due to full updates, inefficient rendering, lack of visibility awareness and object caching mechanism.

[0006] To achieve the above and other related objectives, this invention provides a virtual terminal incremental interface rendering system based on the ISOBUS standard, comprising: an object cache management module for storing and maintaining complete attribute data, version numbers, and hash values ​​of each attribute of all interface objects in the agricultural machinery human-machine interface; a change detection module for calculating new hash values ​​of each attribute based on the attribute update data of the interface objects extracted from ISOBUS messages, comparing the new hash values ​​of each attribute of the interface objects with the hash values ​​of the corresponding attributes cached by the object cache management module, and identifying the attributes that have actually changed; and a differential update generation module for determining the update method of the interface objects based on the attributes that have actually changed, generating update data packets, embedding the current version number of the interface objects in the data packets, and updating the data in the object cache management module.

[0007] The intelligent rendering scheduling module is used to calculate the rendering priority based on the visibility, user attention and update frequency of each interface object, and select the set of objects to be rendered in the current frame according to the target frame rate and rendering time budget; the rendering execution module is used to perform incremental rendering operations on the set of objects to be rendered in the current frame.

[0008] In one embodiment of the present invention, the object cache management module includes: an object storage for storing complete attribute data of all interface objects; a version manager for maintaining a version number for each interface object; an attribute hash table for storing the hash value of each attribute of each interface object; and a dirty tag manager for marking interface objects that need to be re-rendered and their changed attributes using dirty tags.

[0009] In one embodiment of the present invention, the change detection module includes: an attribute hash calculator, used to calculate the new hash value of each attribute of the interface object based on the attribute update data of the interface object using a fast hash algorithm; a difference comparator, used to compare the new hash value of each attribute of the interface object with the hash value of each attribute cached in the attribute hash table to identify the attribute that has actually changed; and a change type classifier, used to classify the attribute that has actually changed to obtain the attribute change type.

[0010] In one embodiment of the present invention, the attribute hash calculator uses a corresponding hash algorithm to calculate hash values ​​for different data lengths; wherein, for short data, a direct hybrid algorithm is used to calculate the new hash values ​​of each attribute of the interface object; for medium data, a complete fast hash algorithm is used to calculate the new hash values ​​of each attribute of the interface object; and for long data, an incremental hash algorithm is used to calculate the new hash values ​​of each attribute of the interface object.

[0011] In one embodiment of the present invention, the differential update generation module includes: an efficiency evaluator, used to calculate the proportion of the number of changed attributes of the interface object to the total number of attributes; if the proportion does not exceed a preset threshold, incremental update is selected, otherwise full update is selected; an incremental data encoder, used to encode the changed attributes into compact differential data packets when incremental update is selected; and a version synchronizer, used to add the current version information to the data update packet.

[0012] In one embodiment of the present invention, the intelligent rendering scheduling module includes: a visibility detector, used to detect whether an interface object is within the current visible area and calculate the ratio of the visible area of ​​the interface object to the total area to obtain the visibility of the interface object; a rendering priority calculator, used to calculate the rendering priority by comprehensively considering the visibility of the interface object, user attention, update frequency, and dirtiness; wherein, user attention is related to whether the interface object is a focus object and whether it has recently been a user interaction object; update frequency is related to the update frequency of the interface object; dirtiness is related to the number of attributes with dirty tags; and a frame budget controller, used to control the number of objects to be rendered in the current frame according to the target frame rate to obtain the set of objects to be rendered in the current frame.

[0013] In one embodiment of the present invention, controlling the number of objects rendered per frame according to the target frame rate includes: calculating the time budget for each frame according to the target frame rate, selecting objects from high to low rendering priority, and accumulating their estimated rendering times until the time budget is reached, thereby obtaining the set of objects to be rendered in the current frame.

[0014] In one embodiment of the present invention, the area to be redrawn is determined for the set of objects to be rendered in the current frame based on the type of attribute change; wherein, if it is a position change type, the entire object area is redrawn; if it is a content change type, the content area is redrawn; and if it is a style change type, the style-related area is redrawn.

[0015] To achieve the above and other related objectives, this invention provides an incremental interface rendering method for virtual terminals based on the ISOBUS standard. The method includes: extracting attribute update data of interface objects for agricultural machinery human-machine interface from ISOBUS messages; calculating new hash values ​​for each attribute of the interface object's attribute update data, comparing the new hash values ​​of each attribute of the interface object with the hash values ​​of the corresponding attributes cached by the object cache management module, and identifying the attributes that have actually changed; determining the update method of the interface object based on the actually changed attributes, generating an update data packet, embedding the current version number of the interface object in the data packet, and updating the stored attribute data, version number, and hash values ​​of the corresponding attributes of the interface object; calculating the rendering priority based on the visibility, user attention, and update frequency of each interface object, and selecting the set of objects to be rendered in the current frame according to the target frame rate and rendering time budget; and performing incremental rendering operations on the set of objects to be rendered in the current frame.

[0016] To achieve the above and other related objectives, the present invention provides an electronic terminal, comprising: one or more memories and one or more processors; the one or more memories are used to store computer programs; the one or more processors are connected to the memories and are used to run the computer programs to execute the ISOBUS-based virtual terminal incremental interface rendering system.

[0017] As described above, this invention is a virtual terminal incremental interface rendering system, method, and terminal based on the ISOBUS standard, which has the following beneficial effects: This invention first calculates the new hash value of each attribute based on the interface object attribute update data extracted from ISOBUS messages, and compares it with the corresponding attribute hash value cached by the object cache management module to accurately identify the actual changed attributes. Based on this, the update method is determined and an update data packet embedded with the current version number is generated. Then, considering the visibility of each interface object, user attention, and update frequency, the rendering priority is calculated. Combining the target frame rate and rendering time budget, the set of objects to be rendered in the current frame is selected, and incremental rendering is performed. This invention achieves efficient incremental updates through technologies such as hash change detection, differential data packet generation, and intelligent rendering scheduling, effectively reducing data transmission volume, improving frame rate, and reducing latency, demonstrating significant performance advantages and broad application prospects. Attached Figure Description

[0018] Figure 1 The diagram shown is a structural schematic of an incremental interface rendering system for virtual terminals based on the ISOBUS standard according to an embodiment of the present invention.

[0019] Figure 2 The diagram shown is a flowchart of an incremental interface rendering system for virtual terminals based on the ISOBUS standard according to an embodiment of the present invention.

[0020] Figure 3 The diagram shows a flowchart of an incremental interface rendering method for virtual terminals according to the ISOBUS standard in one embodiment of the present invention.

[0021] Figure 4 The diagram shown is a structural schematic of an electronic terminal according to an embodiment of the present invention. Detailed Implementation

[0022] The following specific examples illustrate the implementation of the present invention. Those skilled in the art can easily understand other advantages and effects of the present invention from the content disclosed in this specification. The present invention can also be implemented or applied through other different specific embodiments, and various details in this specification can also be modified or changed based on different viewpoints and applications without departing from the spirit of the present invention. It should be noted that, unless otherwise specified, the following embodiments and features described therein can be combined with each other.

[0023] It should be noted that in the following description, reference is made to the accompanying drawings, which illustrate several embodiments of the invention. It should be understood that other embodiments may also be used, and changes in mechanical composition, structure, electrical system, and operation may be made without departing from the spirit and scope of the invention. The following detailed description should not be considered limiting, and the scope of the embodiments of the invention is defined only by the claims of the published patents. The terminology used herein is for the purpose of describing particular embodiments only and is not intended to limit the invention. Spatially related terms, such as “upper,” “lower,” “left,” “right,” “below,” “below,” “lower part,” “above,” “upper part,” etc., may be used herein to illustrate the relationship between one element or feature shown in the figures and another element or feature.

[0024] Throughout this specification, when it is said that a part is "connected" to another part, this includes not only "direct connection" but also "indirect connection" by placing other elements in between. Furthermore, when it is said that a part "includes" a certain constituent element, unless otherwise stated otherwise, this does not exclude other constituent elements, but rather means that other constituent elements may also be included.

[0025] The terms "first," "second," and "third," etc., used herein are for the purpose of describing various parts, components, regions, layers, and / or segments, but are not limiting. These terms are used only to distinguish one part, component, region, layer, or segment from others. Therefore, the "first part," "component," "region," "layer," or "segment" described below may refer to a "second part," "component," "region," "layer," or "segment" without departing from the scope of this invention.

[0026] Furthermore, as used herein, the singular forms “a,” “an,” and “the” are intended to include the plural forms as well, unless the context indicates otherwise. It should be further understood that the terms “comprising,” “including,” indicate the presence of the stated feature, operation, element, component, item, kind, and / or group, but do not preclude the presence, occurrence, or addition of one or more other features, operations, elements, components, items, kinds, and / or groups. The terms “or” and “and / or” as used herein are interpreted as inclusive, or mean any one or any combination thereof. Thus, “A, B, or C” or “A, B, and / or C” means “any one of: A; B; C; A and B; A and C; B and C; A, B, and C.” Exceptions to this definition arise only when combinations of elements, functions, or operations are inherently mutually exclusive in some manner.

[0027] This invention provides an incremental interface rendering system for virtual terminals based on the ISOBUS standard. It first calculates the new hash value of each attribute based on interface object attribute update data extracted from ISOBUS messages, and compares this new hash value with the corresponding attribute hash value cached by the object cache management module to accurately identify the actual changed attributes. Based on this, it determines the update method and generates an update data packet embedding the current version number. Then, considering the visibility of each interface object, user attention, and update frequency, it calculates the rendering priority, combines the target frame rate and rendering time budget, selects the set of objects to be rendered in the current frame, and performs incremental rendering. This invention achieves efficient incremental updates through hash change detection, differential data packet generation, and intelligent rendering scheduling technologies, effectively reducing data transmission volume, improving frame rate, and reducing latency, demonstrating significant performance advantages and broad application prospects.

[0028] The present invention will now be described in detail with reference to the accompanying drawings, so that those skilled in the art can readily implement it. The present invention can be embodied in many different forms and is not limited to the embodiments described herein.

[0029] like Figure 1 This invention presents a schematic diagram of the structure of a virtual terminal incremental interface rendering system based on the ISOBUS standard in an embodiment of the present invention.

[0030] The incremental interface rendering system for virtual terminals based on the ISOBUS standard includes:

[0031] Object cache management module 1 is used to store and maintain the complete attribute data, version number, and hash value of each attribute of all interface objects of the agricultural machinery human-machine interaction interface;

[0032] The change detection module 2 is used to calculate the new hash value of each attribute based on the attribute update data of the interface object extracted from the ISOBUS message, and compare the new hash value of each attribute of the interface object with the corresponding hash value of each attribute cached by the object cache management module to identify the attributes that have actually changed.

[0033] Differential update generation module 3 is used to determine the update method of the interface object based on the actual changed attributes, generate an update data package, embed the current version number of the interface object in the data package, and update the update data and the current version number to the object cache management module.

[0034] The intelligent rendering scheduling module 4 is used to calculate the rendering priority based on the visibility of each interface object, user attention and update frequency, and select the set of objects to be rendered in the current frame according to the target frame rate and rendering time budget.

[0035] Rendering execution module 5 is used to perform incremental rendering operations on the set of objects to be rendered in the current frame.

[0036] In one embodiment, such as Figure 2 The object cache management module 1 includes:

[0037] The object storage system stores complete attribute data for all interface objects as individual entries. Each entry is divided into two parts: basic identification information and an attribute mapping table. The basic identification information acts like an object's identity file. The object ID, a 16-bit unsigned integer, is a unique identifier for each object, ensuring the system can accurately locate each one. The object type is presented as an 8-bit unsigned integer, clearly distinguishing different categories such as buttons and text boxes, providing a category basis for subsequent system processing. The parent object ID constructs the hierarchical relationship of the interface's tree structure, making the hierarchy between objects clear at a glance and facilitating organization and management. The attribute mapping table uses key-value pairs to record complete data for all object attributes. Each attribute entry is rich in content. The attribute value stores raw data such as color RGB values, coordinate positions, and text content, directly determining the object's presentation and function on the interface. The last modification time records the timestamp of the attribute's most recent change, facilitating tracking update timeliness. The modification count counter tracks the total number of modifications an attribute has undergone from creation to the present, aiding in assessing attribute activity and update frequency. Furthermore, object attributes cover multiple aspects such as position, size, color, font, content, graphics, and state, comprehensively defining the characteristics and state of the object.

[0038] The version manager maintains a 32-bit version number for each UI object. This version number serves as a unique identifier for object state changes and is used for cross-module version synchronization, historical state rollback, and version consistency verification across multiple terminals. It ensures consistent data synchronization and avoids errors caused by version differences. For example, when a differential update generation module embeds data packets, it ensures consistent data synchronization between different modules, preventing errors due to version differences. When rendering fails, the version number allows the system to roll back to a historical state, restoring it to the correct state and ensuring system stability and reliability. In environments where multiple terminals are used simultaneously, the version number can verify version consistency across terminals, ensuring that the UI object state displayed on all terminals is consistent.

[0039] The attribute hash table stores a 32-bit hash value for each attribute of each interface object. By storing attribute hash values, the system can quickly and accurately compare whether attributes have changed. When detecting an object attribute update, simply comparing the old and new hash values ​​can efficiently and accurately determine whether the attribute has changed, greatly improving detection efficiency.

[0040] The Dirty Tag Manager uses dirty tags to mark UI objects and their changed attributes that need to be re-rendered. The dirty tag, a Boolean flag, is a global rendering trigger. Once any attribute of an object changes, the tag is automatically set to true, initiating the subsequent rendering process and ensuring timely UI updates. The dirty attribute set precisely records the specific changed attributes within an object, such as color, position, and size, allowing the rendering execution module to perform local redraws on changed areas, avoiding the waste of resources from full redraws and improving rendering performance. The Last Render Time records the timestamp of the object's last rendering; analysis of this timeline allows for evaluation of rendering intervals, identifying performance bottlenecks, and providing direction for system optimization. The Render Count Statistics accumulates the total number of renderings of an object since its creation, assisting the intelligent rendering scheduling module in analyzing object rendering priorities and prioritizing the rendering of frequently updated objects to ensure smooth UI responsiveness.

[0041] In one embodiment, such as Figure 2 The change detection module 2 includes:

[0042] The attribute hash calculator uses a fast hash algorithm to calculate the new hash value for each attribute based on the attribute update data of the interface object. In practice, it extracts the attribute list of the interface object from the ISOBUS message and then calculates the hash value for each attribute one by one. In this way, a unique identifier is generated for each attribute, which can quickly reflect the current state information of the attribute, providing basic data support for subsequent change detection.

[0043] The difference comparator is responsible for identifying attributes that have actually changed. It first compares the newly calculated hash values ​​of each attribute with the old hash values ​​cached in the attribute hash table. If the hash values ​​match, the attribute is determined not to have changed. If the hash values ​​do not match, considering the possibility of hash collisions, it further retrieves the old attribute values ​​from the cache and compares them byte-by-byte with the new attribute values. Only attributes whose actual values ​​differ are considered to have truly changed. Furthermore, the difference comparator also compares the cached full list of attributes with the newly received list to identify deleted attributes, ensuring that changes to all attributes are accurately captured.

[0044] A change type classifier is used to standardize and categorize the results output by the difference comparator. Based on a pre-defined attribute function rule library, it classifies changed attributes into types such as position (e.g., coordinates, hierarchy), appearance (e.g., background color, border), and content (e.g., text, data value). This classification method provides clear guidance for subsequent differential update generation and rendering execution modules. For example, when a change in position attribute is detected, the system redraws the entire object area; while when a change in content attribute occurs, only the content area needs to be redrawn. This precise classification supports the accurate execution of incremental updates and incremental rendering.

[0045] The entire change detection module 2 adopts a lightweight design, making it well-suited for ISOBUS terminal scenarios. It ensures accurate change recognition, capturing every change in the interface objects precisely, while avoiding excessive system resource consumption, ensuring stable and efficient system operation. This is a crucial prerequisite for achieving incremental interface rendering.

[0046] In one embodiment, the attribute hash calculator flexibly selects an appropriate hash algorithm based on the data length when processing data, with MurmurHash3 (32-bit version) as its core algorithm. MurmurHash3 (32-bit version) boasts excellent performance, possessing a high-speed computing capability of approximately 3GB / s, enabling rapid processing of large amounts of data. Its uniform hash distribution effectively avoids hash collisions caused by centralized data distribution. Furthermore, the algorithm has a low collision rate and can accurately generate attribute feature values. These characteristics perfectly meet the needs of ISOBUS virtual terminals, which have limited computing power and require high detection accuracy.

[0047] For attribute data of different lengths, the attribute hash calculator has carefully designed a three-level optimization strategy:

[0048] Short data processing (≤4 bytes): Considering the limited information content of short data, using complex algorithms would not only increase the computational burden but also waste resources. Therefore, the attribute hash calculator abandons complex processes and directly adopts a customized 32-bit mixed function. This function uses simple operations such as bit shifting and multiplication to complete hash calculations at the fastest speed while ensuring a good hash distribution, greatly improving processing efficiency.

[0049] Medium-sized data processing (5-16 bytes): For this type of data, the attribute hash calculator performs the full MurmurHash3 algorithm. The low collision rate of the MurmurHash3 algorithm is fully utilized on this type of data, accurately generating attribute feature values, ensuring the accuracy and uniqueness of attribute data, and providing a reliable basis for subsequent difference comparisons.

[0050] Long data processing (>16 bytes): Calculating the entire long data set consumes significant time and terminal resources, potentially causing system latency. To address this, the attribute hash calculator innovatively employs a sampling hashing strategy, selecting only 20% of the data for hash calculation. While controlling computation time and reducing terminal resource consumption, this scientifically sound sampling method ensures that the generated hash value fully represents the characteristics of the original data, achieving an optimal balance between computational efficiency and result quality.

[0051] This hierarchical processing mechanism fully considers the data characteristics of different types of interface objects in the ISOBUS virtual terminal. For short data, it avoids resource waste caused by over-computation; for long data, it prevents latency issues caused by full-scale computation. Ultimately, it achieves efficient and accurate hash value generation for all types of attribute data, providing reliable basic feature data for subsequent difference comparison, and strongly supporting the accuracy and efficiency of the entire interface update process.

[0052] In one embodiment, such as Figure 2 The differential update generation module 3 includes:

[0053] The efficiency evaluator calculates the proportion of changed attributes of an interface object to the total number of attributes. If the proportion does not exceed a preset threshold, incremental update is selected; otherwise, full update is chosen. Specifically, it first calculates the proportion of changed attributes of an interface object to the total number of attributes, and simultaneously estimates the size of the incremental and full update packets. Using 50% as the core threshold, if the incremental packet size exceeds 50% of the full packet size, the change is considered too large, and a full update is more efficient because it avoids multiple transmissions and complex processing caused by a large incremental packet, saving time and resources overall. Conversely, if the incremental packet size does not exceed 50% of the full packet size, incremental update is selected. This method avoids redundant data transmission and reduces communication overhead. This design fully considers the actual needs of terminal communication, ensuring the scientific and rational nature of update decisions.

[0054] The incremental data encoder comes into play when the efficiency evaluator decides to use incremental updates, encoding the changed attributes into compact differential data packets.

[0055] The version synchronizer is used to embed the current version information in all update packages (incremental or full packages), ensuring that the object cache management module can complete the synchronization verification through the version information after receiving the data package, avoiding cross-version update conflicts, and providing support for subsequent version tracing and rollback.

[0056] The differential data packet structure is meticulously designed, containing a header and a list of changed attributes. The header records crucial information such as packet type, target object ID, base version number, new version number, and the number of changed attributes, providing clear guidance for subsequent processing. Each item in the changed attribute list includes the attribute ID, the length of the new value, and the new value itself. Optionally, longer values ​​can be compressed to further reduce packet size. A checksum is appended to the end of the packet to ensure data transmission integrity. Upon receiving and applying the differential packet, the system performs rigorous verification and processing. First, it verifies the checksum to ensure no errors occurred during transmission. Then, it locates the corresponding object in the cache based on the object ID in the packet and checks if the base version number in the packet matches the object's current version number to prevent version inconsistencies. After successful verification, the system iterates through the changed attribute list in the packet, updating or deleting each cached object attribute, updating the object's version number, dirty flag, and last modified time to ensure the object's state is consistent with the latest update.

[0057] Similarly, the full package can also include a checksum at the end. When receiving and applying the full package, the system uses the object ID in the package to find the corresponding object in the cache and verifies whether the base version number in the package matches the current version number of the object, preventing issues caused by version inconsistencies. After successful verification, the system iterates through the package, updating or deleting each object attribute in the cache, and updating the object's version number, dirty flag, and last modified time to ensure that the object's state is consistent with the latest update. Through this series of rigorous processing steps, the differential update generation module 3 can efficiently and accurately complete the interface update task, providing strong support for the stable operation of the system and a good user experience.

[0058] In one embodiment, such as Figure 2 The intelligent rendering scheduling module 4 includes:

[0059] The visibility detector is responsible for accurately identifying the visibility status and degree of visibility of interface objects. In its operation, it first uses a spatial index structure to quickly locate potential visible objects within the current screen viewport. This step leverages the efficient query characteristics of the spatial index structure to rapidly narrow down the detection range and improve detection efficiency. Next, the potential visible objects are sorted from back to front according to the Z-axis order. The Z-axis order determines the display hierarchy of objects in the vertical direction, and sorting clarifies the occlusion relationships between objects, providing a foundation for subsequent visibility calculations. Then, a scanline algorithm is used to traverse the interface starting from the top-level objects. During the traversal, the unoccluded visible area of ​​each object is calculated sequentially. If an object's visible area is empty, it is marked as invisible. Finally, a visibility score is generated based on the ratio of the object's visible area to its total area. This score serves as a crucial basis for subsequent priority calculations; a higher score indicates better visibility and a higher priority for processing. At the same time, the visibility detector also records detailed visibility status information of objects, including visibility flags indicating whether the object is within the visible area of ​​the screen, the visible area of ​​the actual visible rectangular area of ​​the object (after considering occlusion), the occlusion relationship of which other objects occlude it, and the Z-axis order that determines the vertical display layer of the object.

[0060] The rendering priority calculator is used to calculate rendering priority by comprehensively considering the visibility of UI objects, user attention, update frequency, and dirtiness.

[0061] Visibility Score (V): Provided by the visibility detector, it directly determines whether an object needs to be rendered. Completely invisible objects have a V value of 0, which directly lowers their priority and avoids unnecessary rendering.

[0062] User Attention Score (U): Objects currently in focus, objects that have been recently interacted with, and objects located in the center of the screen or near the touch point will receive higher scores. This focuses on the core needs of human-computer interaction, ensuring that user-responsive elements are rendered first.

[0063] Update Frequency Rating (F): Objects that are updated frequently, such as real-time job data charts, will receive a higher rating. This ensures that dynamic data is displayed promptly, meeting users' needs for real-time information.

[0064] Dirtyness Rating (D): This is the proportion of changed attributes out of the total number of attributes. The more significant the change, the higher the priority of the object. Prioritize processing content that needs updating to reduce interface latency.

[0065] In terms of specific calculation methods, a weighted summation formula is used:

[0066] RenderPriority = w1 × V + w2 × U + w3 × F + w4 × D; (Formula 1)

[0067] Each dimension's metrics and weighting coefficients have been designed for scenario adaptation: Visibility score (V) is weighted at 0.35, serving as a basic filtering condition; completely invisible objects have a V value of 0, which directly reduces their priority and avoids invalid rendering; User attention score (U) is weighted at 0.30, focusing on the core needs of human-computer interaction; focused objects, recently interacted objects, or objects near touch points will receive higher U values, ensuring that user-operated elements are rendered first; Update frequency score (F) is weighted at 0.15; frequently updated dynamic objects, such as real-time job data and alarm prompts, have higher F values, ensuring the timeliness of data display; Dirtyness score (D) is weighted at 0.20; objects with a higher proportion of changing attributes have larger D values, prioritizing content that needs updating and reducing interface latency.

[0068] Furthermore, to address specific scenario requirements, global special rules have been established. Alarm-type objects, such as agricultural machinery malfunction alarms and operational safety prompts, are not subject to formulaic scoring and always have the highest priority, ensuring that critical warning information is rendered immediately. Hidden objects (V value of 0) are directly determined to have the lowest priority and are excluded from the rendering queue. This design achieves standardized evaluation while covering extremely important scenarios, avoiding the limitations of formulaic evaluation. It ensures that the ISOBUS terminal can efficiently handle routine interface rendering in scenarios such as agricultural machinery operations while prioritizing the response to safety-related critical content.

[0069] The frame budget controller controls the number of objects rendered per frame based on the target frame rate, ensuring a stable frame rate and preventing stuttering. It dynamically adjusts the number of objects that can be rendered per frame based on system performance and the target frame rate. When system performance is good and the target frame rate is high, it allows more objects to be rendered per frame; when system performance degrades or the target frame rate is low, it appropriately reduces the number of objects rendered per frame, thus balancing rendering quality and performance to provide users with a smooth user experience.

[0070] In one embodiment, the frame budget controller controls the number of objects rendered per frame based on the target frame rate, including:

[0071] First, accurately calculating the time budget for each frame based on the target frame rate is fundamental to the entire process. The frame budget controller, using the FrameBudgetScheduling algorithm, precisely determines the total available time for each frame during the budget calculation phase, based on the set target frame rate. Considering the unique operating characteristics of terminal systems, to avoid excessive rendering resource consumption by low-level system operations leading to stuttering, the algorithm reserves 2ms as basic overhead for the rendering system, allocating the remaining time specifically to the actual rendering of UI objects, thus clearly defining the time limits for rendering operations.

[0072] Next, sorting all objects to be rendered from highest to lowest priority is a crucial step. Different types of objects, such as text, numbers, images, and graphics, have different rendering characteristics, thus requiring the development of targeted, differentiated rendering time estimation rules. For example, text is estimated by adding the text length multiplied by 0.01ms to the base time, numbers by adding 0.2ms to the base time, images by adding the number of pixels multiplied by 0.00001ms to the base time, and graphics by adding the number of points multiplied by 0.02ms to the base time. These rules help the frame budget controller accurately control the number of objects rendered per frame, allocate resources reasonably, and ensure stable and efficient rendering of the interface and a smooth visual experience.

[0073] The algorithm then starts with the highest priority object and gradually accumulates its estimated rendering time. During this accumulation process, it continuously compares the estimated time with the remaining time budget until the remaining time budget is reached. The accumulated objects at this point form the set of rendering objects for the current frame. However, in agricultural machinery operation scenarios, there is a special handling mechanism for extremely high-priority objects such as alarm pop-ups. Even if the time for accumulating these extremely high-priority objects exceeds the budget range, the algorithm will still forcibly include them in the rendering list to ensure that core warning information is displayed in a timely manner, fully adapting to the strict safety requirements of this scenario.

[0074] Furthermore, to maintain overall frame rate stability, the algorithm meticulously records the timeout status of each frame. If a frame exceeds the budget due to forcibly rendering high-priority objects, subsequent frames will compensate by reducing the number of low-priority objects. This flexible and elastic compensation strategy ensures the rendering priority of critical objects while preventing continuous stuttering, allowing the entire rendering process to proceed in a stable state.

[0075] Overall, the FrameBudgetScheduling algorithm achieves optimal allocation of rendering resources through quantified time budget settings, refined object classification estimation methods, and flexible elastic compensation strategies. While ensuring rendering efficiency, it also considers the real-time requirements of terminal operations, providing strong support for intelligent rendering scheduling and enabling the interface to maintain a smooth and stable display effect in various complex scenarios.

[0076] In one embodiment, the area that needs to be redrawn is determined for the set of objects to be rendered in the current frame based on the type of attribute change;

[0077] Extract the dirty attribute set of the object set to be rendered in the current frame from the dirty tag manager to determine the type of region that needs to be redrawn;

[0078] Type of Position Change: When an object's position changes, the entire object area is redrawn. This is because a position change is not an isolated event; it can significantly impact the layout relationship between the object and surrounding elements. For example, in a UI layout, if a button moves upwards, it might obscure elements that were previously above it, or alter the spacing between it and previously adjacent elements. To ensure consistency and accuracy in display, and to make the entire interface look natural and harmonious, redrawing the entire object area is necessary. Through redrawing, the positional relationships between the object and surrounding elements can be recalculated, ensuring that the display of all elements conforms to the new layout requirements.

[0079] Content Change Type: If the content of an object changes, such as text modification or image replacement, only the content area is redrawn. This avoids unnecessary redrawing operations and improves rendering efficiency. For example, in a text box, if the user only modifies a few characters, redrawing the entire text box would require redrawing the border, background, and everything else, when only the modified characters need updating. Redrawing only the changed content area reduces system resource consumption and makes the rendering process more efficient.

[0080] Style Change Type: When an object's style changes, such as color, font, or border style, the affected areas are redrawn. Style changes typically don't significantly impact the overall layout of the object; they primarily affect its appearance. For example, if a button's background color changes from blue to red, only the background needs to be redrawn; the button's shape, position, and other attributes don't need to be redrawn. Redrawing only the style-affected areas ensures the display matches expectations while optimizing rendering performance and avoiding unnecessary calculations and drawing operations.

[0081] The number of changing attributes is also considered when determining the redraw area. When an object has too many changing attributes, such as more than half of the total number of attributes, redrawing the entire object directly may be more efficient. This is because, in this case, processing each changing attribute individually requires calculating the impact of each attribute's change on the display and then performing the corresponding drawing operations, which may consume more time and system resources. A complete redraw, on the other hand, can directly complete the drawing task based on the object's latest state in one go. Although it seems like more drawing work is done, it actually completes rendering faster, reducing intermediate calculations and judgments, thereby improving overall rendering efficiency.

[0082] Throughout the rendering process, the system uses double buffering to optimize display quality. Double buffering involves creating a back buffer in memory corresponding to the screen display area, where all drawing operations are first performed. After drawing is complete in the back buffer, its contents are then brought to the foreground all at once. This avoids screen flicker. Without double buffering, users might see incomplete images during rendering, causing flickering. With double buffering, users always see a complete image, thus improving the visual experience.

[0083] After rendering is complete, the dirty flag for the object is cleared. A dirty flag is an indicator used to mark whether an object needs to be redrawn. When an object's properties change, the system sets a dirty flag for that object, indicating that it needs to be redrawn. After determining the redraw area and performing the redraw operation, it means the object has been updated according to the latest property state. At this point, clearing the dirty flag indicates that the object does not need to be redrawn again in its current state until its properties change again. This avoids repeatedly redrawing the same object, further improving rendering efficiency.

[0084] In one embodiment, an adaptive quality adjustment mechanism is also employed. By continuously monitoring the ratio of the actual frame rate to the target frame rate and the CPU idle rate, when the actual frame rate is lower than a certain threshold of the target frame rate (e.g., lower than 80%), it is determined that the rendering load is too high. Measures such as reducing the number of rendering objects per frame, increasing the frame skipping threshold, and reducing anti-aliasing and texture quality are automatically taken to reduce rendering quality and ensure smoothness. Conversely, when the frame rate meets the target and the CPU idle resources exceed the threshold (e.g., 30%), the number of rendering objects per frame is increased, the frame skipping threshold is decreased, and anti-aliasing and texture quality are improved. This dynamically balances performance and image quality, and improves user experience and resource utilization.

[0085] Similar to the principles of the above embodiments, the present invention provides an incremental interface rendering method for virtual terminals based on the ISOBUS standard.

[0086] The following specific embodiments are provided in conjunction with the accompanying drawings:

[0087] like Figure 3 This document illustrates a flowchart of an incremental interface rendering method for a virtual terminal based on the ISOBUS standard, as described in an embodiment of the present invention. The method includes:

[0088] Step S1: Extract the attribute update data of the interface object of the agricultural machinery human-machine interface from the ISOBUS message.

[0089] Step S2: Calculate the new hash value of each attribute for the attribute update data of the interface object, and compare the new hash value of each attribute of the interface object with the hash value of the corresponding attribute cached by the object cache management module to identify the attributes that have actually changed.

[0090] Step S3: Based on the actual changed attributes, determine the update method of the interface object, generate an update data package, embed the current version number of the interface object in the data package, and update the stored attribute data, version number, and hash value of the corresponding attribute of the interface object.

[0091] Step S4: Calculate the rendering priority based on the visibility, user attention and update frequency of each interface object, and select the set of objects to be rendered in the current frame according to the target frame rate and rendering time budget.

[0092] Step S5: Perform incremental rendering operation on the set of objects to be rendered in the current frame.

[0093] Since the implementation principle of the incremental interface rendering method for virtual terminals based on the ISOBUS standard has been described in the previous embodiments, it will not be repeated here.

[0094] The incremental interface rendering system for virtual terminals based on the ISOBUS standard provided in this embodiment of the invention can be implemented on the terminal side or the server side. For details regarding the hardware structure of the electronic terminal, please refer to [link to relevant documentation]. Figure 4 This is a schematic diagram of an optional hardware structure of an electronic terminal 1000 provided in an embodiment of the present invention. The terminal 1000 can be a mobile phone, computer device, tablet device, personal digital processing device, factory back-end processing device, etc. The terminal 1000 includes: at least one processor 1001, a memory 1002, at least one network interface 10010, and a user interface 1009. The various components in the device are coupled together through a bus system 1005. It is understood that the bus system 1005 is used to realize the connection and communication between these components. In addition to a data bus, the bus system 1005 also includes a power bus, a control bus, and a status signal bus. However, for clarity, in... Figure 4 All buses are labeled as bus systems.

[0095] The user interface 1009 may include a monitor, keyboard, mouse, trackball, clicker, button, touchpad, or touch screen.

[0096] It is understood that memory 1002 can be volatile memory or non-volatile memory, or both. Non-volatile memory can be read-only memory (ROM) or programmable read-only memory (PROM), which serves as an external cache. By way of example, but not limitation, many forms of RAM are available, such as static random access memory (SRAM) and synchronous static random access memory (SSRAM). The memories described in the embodiments of this invention are intended to include, but are not limited to, these and any other suitable categories of memory.

[0097] In this embodiment of the invention, the memory 1002 is used to store various types of data to support the operation of the terminal 1000. Examples of this data include: any executable program for operation on the terminal 1000, such as the operating system 10021 and application program 10022; the operating system 10021 contains various system programs, such as the framework layer, core library layer, driver layer, etc., for implementing various basic services and handling hardware-based tasks. The application program 10022 may contain various applications, such as a media player, browser, etc., for implementing various application services. The virtual terminal incremental interface rendering system based on the ISOBUS standard provided in this embodiment of the invention can be included in the application program 10022.

[0098] The methods disclosed in the above embodiments of the present invention can be applied to or implemented by the processor 1001. The processor 1001 may be an integrated circuit chip with signal processing capabilities. In the implementation process, each step of the above method can be completed by the integrated logic circuit of the hardware in the processor 1001 or by instructions in the form of software. The processor 1001 may be a general-purpose processor, a digital signal processor (DSP), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. The processor 1001 can implement or execute the methods, steps, and logic block diagrams disclosed in the embodiments of the present invention. The general-purpose processor 1001 may be a microprocessor or any conventional processor, etc. The steps of the accessory optimization method provided in the embodiments of the present invention can be directly reflected as being executed by a hardware decoding processor, or being executed by a combination of hardware and software modules in the decoding processor. The software module may be located in a storage medium, which is located in a memory. The processor reads the information in the memory and combines it with its hardware to complete the steps of the aforementioned method.

[0099] In an exemplary embodiment, the terminal 1000 may be used to execute the aforementioned method by one or more application-specific integrated circuits (ASICs), DSPs, programmable logic devices (PLDs), or complex programmable logic devices (CPLDs).

[0100] Those skilled in the art will understand that all or part of the steps of the above-described method embodiments can be implemented using computer program-related hardware. The aforementioned computer program can be stored in a computer-readable storage medium. When executed, the program performs the steps of the above-described method embodiments; and the aforementioned storage medium includes various media capable of storing program code, such as ROM, RAM, magnetic disks, or optical disks.

[0101] In the embodiments provided in this application, the computer-readable and writable storage medium may include read-only memory, random access memory, EEPROM, CD-ROM or other optical disc storage devices, disk storage devices or other magnetic storage devices, flash memory, USB flash drive, portable hard drive, or any other medium capable of storing desired program code in the form of instructions or data structures and accessible by a computer. Additionally, any connection may be appropriately referred to as a computer-readable medium. For example, if instructions are transmitted from a website, server, or other remote source using coaxial cable, fiber optic cable, twisted pair, digital subscriber line (DSL), or wireless technologies such as infrared, radio, and microwave, then the coaxial cable, fiber optic cable, twisted pair, DSL, or wireless technologies such as infrared, radio, and microwave are included in the definition of medium. However, it should be understood that computer-readable and writable storage media and data storage media do not include connections, carrier waves, signals, or other transient media, but are intended for non-transient, tangible storage media. The disks and optical discs used in the application include compact optical discs (CDs), laser optical discs, optical discs, digital multifunction optical discs (DVDs), floppy disks, and Blu-ray discs, where disks typically copy data magnetically, while optical discs use lasers to copy data optically.

[0102] In summary, the incremental interface rendering system, method, and terminal for virtual terminals based on the ISOBUS standard of this invention first calculates the new hash value of each attribute based on the interface object attribute update data extracted from ISOBUS messages, and compares it with the corresponding attribute hash value cached by the object cache management module to accurately identify the actual changed attributes. Based on this, the update method is determined and an update data packet embedded with the current version number is generated. Then, considering the visibility of each interface object, user attention, and update frequency, the rendering priority is calculated. Combining the target frame rate and rendering time budget, the set of objects to be rendered in the current frame is selected, and incremental rendering is performed. This invention achieves efficient incremental updates by utilizing technologies such as hash change detection, differential data packet generation, and intelligent rendering scheduling, effectively reducing data transmission volume, improving frame rate, and reducing latency, demonstrating significant performance advantages and broad application prospects. Therefore, this invention effectively overcomes the various shortcomings of existing technologies and has high industrial application value.

[0103] The above embodiments are merely illustrative of the principles and effects of the present invention and are not intended to limit the invention. Any person skilled in the art can modify or alter the above embodiments without departing from the spirit and scope of the present invention. Therefore, all equivalent modifications or alterations made by those skilled in the art without departing from the spirit and technical concept disclosed in the present invention should still be covered by the claims of the present invention.

Claims

1. A virtual terminal incremental interface rendering system based on the ISOBUS standard, characterized in that, include: The object cache management module is used to store and maintain the complete attribute data, version number, and hash value of each attribute of all interface objects in the human-machine interface of agricultural machinery. The change detection module is used to calculate the new hash value of each attribute based on the attribute update data of the interface object extracted from the ISOBUS message, and compare the new hash value of each attribute of the interface object with the hash value of the corresponding attribute cached by the object cache management module to identify the attribute that has actually changed. The differential update generation module is used to determine the update method of the interface object based on the actual changed attributes, generate an update data package, embed the current version number of the interface object in the data package, and update the data of the object cache management module. The intelligent rendering scheduling module is used to calculate the rendering priority based on the visibility, user attention and update frequency of each interface object, and select the set of objects to be rendered in the current frame according to the target frame rate and rendering time budget. The rendering execution module is used to perform incremental rendering operations on the set of objects to be rendered in the current frame.

2. The virtual terminal incremental interface rendering system based on the ISOBUS standard as described in claim 1, characterized in that, The object cache management module includes: Object storage, used to store complete attribute data for all UI objects; A version manager is used to maintain a version number for each UI object; An attribute hash table is used to store the hash value of each attribute of each interface object; The dirty tag manager is used to mark UI objects that need to be re-rendered and their changed properties using dirty tags.

3. The virtual terminal incremental interface rendering system based on the ISOBUS standard as described in claim 2, characterized in that, The change detection module includes: The attribute hash calculator is used to calculate the new hash value of each attribute of a UI object based on the attribute update data of the UI object using a fast hash algorithm. The difference comparator is used to compare the new hash values ​​of each attribute of the interface object with the hash values ​​of each attribute cached in the attribute hash table to identify the attributes that have actually changed. A change type classifier is used to classify attributes that actually change to obtain the attribute change type.

4. The virtual terminal incremental interface rendering system based on the ISOBUS standard as described in claim 3, characterized in that, The attribute hash calculator uses corresponding hash algorithms to calculate hash values ​​for different data lengths. Specifically, for short data, a direct hybrid algorithm is used to calculate the new hash values ​​of each attribute of the interface object; for medium-sized data, a complete fast hash algorithm is used to calculate the new hash values ​​of each attribute of the interface object; and for long data, an incremental hash algorithm is used to calculate the new hash values ​​of each attribute of the interface object.

5. The virtual terminal incremental interface rendering system based on the ISOBUS standard as described in claim 3, characterized in that, The differential update generation module includes: The efficiency evaluator is used to calculate the proportion of the number of attributes of the interface object that have changed to the total number of attributes. If the proportion does not exceed a preset threshold, incremental update is selected; otherwise, full update is selected. An incremental data encoder is used to encode changed attributes into compact differential data packets when selecting incremental updates; A version synchronizer is used to add the current version information to data update packages.

6. The virtual terminal incremental interface rendering system based on the ISOBUS standard as described in claim 5, characterized in that, The intelligent rendering scheduling module includes: A visibility detector is used to detect whether an interface object is within the current visible area and to calculate the ratio of the visible area of ​​the interface object to the total area to obtain the visibility of the interface object. The rendering priority calculator is used to calculate the rendering priority by comprehensively considering the visibility of UI objects, user attention, update frequency, and dirtyness. Among them, user attention is related to whether the UI object is the focus object and whether it has recently been the user's interaction object; update frequency is related to the update frequency of the UI object; and dirtyness is related to the number of attributes with dirty tags. The frame budget controller is used to control the number of objects rendered in the current frame based on the target frame rate, and to obtain the set of objects to be rendered in the current frame.

7. The virtual terminal incremental interface rendering system based on the ISOBUS standard as described in claim 6, characterized in that, The method of controlling the number of objects rendered per frame based on the target frame rate includes: Calculate the time budget for each frame based on the target frame rate, select objects from high to low rendering priority, and accumulate their estimated rendering times until the time budget is reached, thus obtaining the set of objects to be rendered in the current frame.

8. The virtual terminal incremental interface rendering system based on the ISOBUS standard as described in claim 7, characterized in that, For the set of objects to be rendered in the current frame, determine the areas that need to be redrawn based on the type of attribute change. If the change is a positional change, then the entire object area is redrawn; If the content changes, then redraw the content area; If it is a style change type, then redraw the style-related area.

9. A virtual terminal incremental interface rendering method based on the ISOBUS standard, characterized in that, The method includes: Extract attribute update data of the interface object of the human-machine interface of agricultural machinery from ISOBUS messages; The new hash value of each attribute is calculated for the attribute update data of the interface object, and the new hash value of each attribute of the interface object is compared with the hash value of the corresponding attribute cached by the object cache management module to identify the attribute that has actually changed. Based on the actual changes in attributes, determine the update method of the interface object, generate an update data package, embed the current version number of the interface object in the data package, and update the stored attribute data, version number, and hash value of the corresponding attribute of the interface object. Rendering priority is calculated based on the visibility, user attention, and update frequency of each interface object, and the set of objects to be rendered in the current frame is selected according to the target frame rate and rendering time budget. Perform incremental rendering on the set of objects to be rendered in the current frame.

10. An electronic terminal, characterized in that, include: One or more memories and one or more processors; The one or more memories are used to store computer programs; The one or more processors are connected to the memory and are used to run the computer program to perform the method as described in claim 9.

Images