Picture preloading method based on image annotation

Abstract

The invention relates to the field of intelligent manufacturing image data annotation, in particular to a picture preloading method based on image annotation. The method comprises the following steps of: setting a size threshold value for an unlabeled data packet, subpackaging according to a preset mode after the corresponding size threshold value is reached, and matching a data loading rule and a data preloading rule with preset sizes; loading and rendering unlabeled data on the labeled page, and receiving labeled information; after identifying the annotation information, loading preloading data in a non-display area of the annotation page; and carrying out rendering on the pre-loaded data when the loaded page is changed into an annotated page display area. The method is used for solving the problem of labeling efficiency.

Description

Technical Field

[0001] The present invention relates to the field of intelligent manufacturing image data annotation, and in particular to a picture preloading method based on image annotation. Background Art

[0002] In the field of industrial intelligent manufacturing, image annotation technology is widely used in quality inspection, production line monitoring, equipment maintenance and other aspects. By annotating a large number of images generated during the production process, and then performing machine learning and automatic defect recognition, production efficiency and yield can be greatly improved. However, with the continuous increase in the amount of image data in industrial manufacturing, the efficiency and experience of annotation need to be further improved.

[0003] Currently, many industrial image annotation systems rely on synchronous image loading, that is, obtaining images from the server in real time and displaying and processing them when the annotation task is executed. This method can meet basic needs when the network conditions are good and the data volume is small, but in actual production environments, network bandwidth and system resources are often limited, resulting in slow image loading speed, affecting annotation efficiency and system response time. At the same time, if the annotator is an experienced person, this synchronous loading method will also slow down efficiency. Summary of the invention

[0004] In order to solve the impact of annotation efficiency, network bandwidth and system resources mentioned in the above background technology center, the present invention provides a picture preloading method based on image annotation, which includes the steps of:

[0005] A method for preloading pictures based on image annotation, characterized in that it comprises the steps of:

[0006] Setting a size threshold for unlabeled data packets, and when the size threshold is reached, packetizing is performed in a preset manner and matching the loading data rule and preloading data rule of the preset size;

[0007] Load unlabeled data on the labeling page and render it, and receive labeling information;

[0008] After identifying the annotation information, preload data is loaded in the undisplayed area of ​​the annotation page;

[0009] The preloaded data is rendered when the loading page becomes the marked page display area.

[0010] By setting size thresholds and packetization strategies, the efficiency of data loading and preloading is improved, and waiting time is reduced. At the same time, the preset size loading data rules and preloading data rules can better optimize the consumption of network and system resources. The rendering of preloaded data is performed after the area is switched to the display state, and the immediacy can be quickly guaranteed. During the page scrolling or sliding, rendering is performed according to this switching standard, which can synchronize the rendering and the annotator's rhythm and improve the annotation efficiency.

[0011] Specifically, the preloading data rule includes preloading data based on the annotated historical information. The preloading is performed using the annotated historical information, which improves the accuracy and effectiveness of the preloading.

[0012] Specifically, when the loading page becomes the marked page display area, before rendering, the preloaded data is dynamically adjusted to adapt to changes in network bandwidth. The preloaded data volume is dynamically adjusted to ensure that a good loading effect can be obtained under different network bandwidth environments.

[0013] Specifically, the steps include: compressing the labeled data to save storage space. Compressing the labeled data saves storage space and improves system efficiency. At the same time, it cooperates with the above-mentioned "rendering of preloaded data is performed after the area is switched to display state", so that the entire labeled page is only in a high-energy consumption state when the display page is displayed, and the data that has not been rendered is low-energy consumption. The data that has been rendered and labeled is also low-energy consumption because of the compression action. In this way, when the amount of image data in industrial manufacturing is very large, for some labeling work that needs to continue for several months, it is a very good way to save system resources, and prevent the situation where the data is saved, closed, and then opened after a period of labeling.

[0014] Specifically, the preset size loading data rule and preloading data rule include a complexity trade-off based on the content of the unlabeled image data. The loading rule is adjusted based on the complexity of the image content, thereby improving loading efficiency and labeling accuracy.

[0015] Specifically, multi-threading technology is used in the preloading process, which significantly improves the preloading speed and reduces the annotation waiting time.

[0016] Specifically, when the annotation page is rendered, the operation path of the annotator is predicted in advance and the corresponding data is preloaded. Predicting the operation path of the annotator and preloading improves the fluency and efficiency of the annotation process.

[0017] Specifically, during the preloading process, the network environment of the annotator is monitored in real time, and the preloading strategy is adjusted dynamically according to the network environment. The network environment is monitored in real time and the preloading strategy is adjusted to ensure the best loading experience under different network conditions.

[0018] A computer device is also disclosed, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor implements the image preloading method when executing the computer program. The computer device integrated with the preloading method improves the overall system performance and user experience.

[0019] A computer-readable storage medium is also disclosed, on which a computer program is stored, and when the computer program is executed by a processor, the image preloading method is implemented. The convenient deployment and use of the preloading method is realized through the computer-readable storage medium, which improves the usability and adaptability of the system. BRIEF DESCRIPTION OF THE DRAWINGS

[0020] In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings required for use in the embodiments are briefly introduced below. It should be understood that the following drawings only show certain embodiments of the present invention and therefore should not be regarded as limiting the scope. For ordinary technicians in this field, other related drawings can be obtained based on these drawings without creative work.

[0021] Figure 1 It is a flow chart of embodiment 1 of the present invention. DETAILED DESCRIPTION

[0022] It should be understood that the specific embodiments described herein are only used to explain the present application and are not used to limit the present application.

[0023] In order to solve the defects of the prior art mentioned in the background technology center, this embodiment provides a picture preloading method based on image annotation, which is characterized by comprising the steps of:

[0024] Setting a size threshold for unlabeled data packets, and when the size threshold is reached, packetizing is performed in a preset manner and matching the loading data rule and preloading data rule of the preset size;

[0025] Load unlabeled data on the labeling page and render it, and receive labeling information;

[0026] After identifying the annotation information, preload data is loaded in the undisplayed area of ​​the annotation page;

[0027] The preloaded data is rendered when the loading page becomes the marked page display area.

[0028] By setting size thresholds and packetization strategies, the efficiency of data loading and preloading is improved, and waiting time is reduced. At the same time, the preset size loading data rules and preloading data rules can better optimize the consumption of network and system resources. The rendering of preloaded data is performed after the area is switched to the display state, and the immediacy can be quickly guaranteed. During the page scrolling or sliding, rendering is performed according to this switching standard, which can synchronize the rendering and the annotator's rhythm and improve the annotation efficiency.

[0029] Specifically, the preloading data rule includes preloading data based on annotation history information. Preloading using annotation history information improves the accuracy and effectiveness of preloading. Combined with natural language processing (NLP) technology, the operation history and behavior patterns of the annotators are analyzed to optimize the preloading strategy and further improve the accuracy and effectiveness of preloading. The specific implementation method includes: using RNN (recurrent neural network) or LSTM (long short-term memory network) models to model the operation sequence of the annotator and predict their future operation path. Use NLP technology to perform text analysis on the annotator's operation log and extract key features, such as annotation frequency, annotation time interval, and common operation modes. The extracted features are input into machine learning algorithms such as decision trees or random forests to generate optimized preloading strategies.

[0030] Specifically, when the loading page becomes the display area of ​​the annotation page, the amount of preloaded data is dynamically adjusted before rendering to adapt to changes in network bandwidth. The amount of preloaded data is dynamically adjusted to ensure that good loading effects can be obtained under different network bandwidth environments. At the same time, an adaptive algorithm is used to dynamically adjust the preloading strategy according to the network environment and the operating habits of the annotator to ensure the best loading experience under different network conditions. The implementation method includes: monitoring the current network bandwidth in real time through a bandwidth monitoring module, and calculating the real-time mean and variance of the bandwidth using a sliding window algorithm. Based on the calculation results, a linear regression model is used to predict the bandwidth change trend in the short term in the future, and the amount of preloaded data is dynamically adjusted. In terms of the annotator's operating habits, by analyzing their operating history, the K-means clustering algorithm is used to classify different types of operating habits and generate corresponding preloading strategies. The adaptive algorithm combines the results of bandwidth monitoring and operating habit analysis, and uses a weighted decision tree model to dynamically select the optimal preloading strategy.

[0031] The specific steps of using the K-means clustering algorithm to classify different types of operating habits and generate corresponding preloading strategies are as follows:

[0032] Data collection and preprocessing:

[0033] Relevant data are extracted from the labelers’ operation logs, including operation time, operation type, labeling frequency, labeling time interval, etc. These data are cleaned and standardized to ensure data consistency and comparability.

[0034] Feature selection and extraction:

[0035] Select meaningful features, such as operation frequency (number of operations per unit time), operation interval (time difference between adjacent operations), and operation type (annotation, modification, deletion, etc.) and vectorize these features, that is, convert each annotator's operation habits into a multi-dimensional feature vector.

[0036] Use K-means clustering algorithm for cluster analysis:

[0037] Set the number of clusters \k\, that is, how many categories you want to divide the operation habits into. Initialize \k\ cluster centers.

[0038] For each operation habit feature vector \x_i\, calculate its distance to each cluster center\\mu_j\, and assign \x_i\ to the nearest cluster center: $$d(x_i,\mu_j)=\|x_i-\mu_j\|$$

[0039] Update each cluster center to the average of all its members: $$\mu_j=\frac{1}{|S_j|}\sum_{x\in S_j}x$$where \S_j\ is the set of all feature vectors assigned to the \j\th cluster center.

[0040] Repeat the above steps until the cluster center no longer changes significantly or the maximum number of iterations is reached.

[0041] Generate a preload strategy:

[0042] For each cluster, the average value and distribution of its feature vector are analyzed to determine the common operation habits of the annotators in the cluster. According to the clustering results, the corresponding preloading strategy is generated. For example, for clusters with high operation frequency, the amount of preloaded data can be increased; for clusters with long operation intervals, the amount of preloaded data can be reduced to save resources.

[0043] Strategy application and optimization:

[0044] Apply the generated preloading strategy to the actual system and adjust the preloading data in real time to adapt to different types of operating habits. Continuously monitor and evaluate the effectiveness of the strategy, and use feedback data to optimize the clustering algorithm and preloading strategy.

[0045] Specifically, the method further includes the steps of: compressing the labeled data to save storage space. Compressing the labeled data saves storage space and improves system efficiency. At the same time, in conjunction with the above-mentioned "rendering of preloaded data is performed after the region is switched to display state", only the display page of the entire labeled page is in high energy consumption state, and the unrendered data is low energy consumption. The rendered and labeled data is also low energy consumption because of the compression action. In this way, when the amount of image data in industrial manufacturing is very large, for some labeling work that needs to last for several months, it is a very good way to save system resources, and prevent the situation where the labeling is saved, closed and reopened after a period of labeling. Introduce edge computing technology to move some preloading and data processing tasks to edge devices to reduce latency and improve system response speed. The specific implementation method includes: using compression algorithms (such as JPEG, PNG or WebP) to compress the labeled image data to reduce storage occupancy. Differentially compress the labeled data to store only the incremental data of each labeling, further reducing storage space. Optimize the compression effect through a convolutional neural network (CNN) to ensure that the image quality is maintained during the compression process. Implement preliminary data processing and compression on edge devices to reduce the burden on central servers.

[0046] To perform differential compression on the labeled data and optimize the compression effect through a convolutional neural network (CNN), the following steps can be followed:

[0047] Differential Compression:

[0048] Initial data storage: Stores the initial complete image data as a baseline.

[0049] Incremental data generation: After each annotation operation, the difference between the image data and the last annotation is calculated to generate incremental data (differential data). This difference can be achieved through pixel-level comparison, storing the changed part instead of the entire image.

[0050] For example, assuming that the initial image data is \I_0\, and the image data after the \n\th annotation is \I_n\, the differential data \D_n\ can be expressed as: $$D_n=I_n-I_{n-1}$$, where \D_n\ is the incremental data after the \n\th annotation.

[0051] Incremental data storage: Incremental data is stored so that the full image can be reconstructed when needed. This approach greatly reduces the amount of data that needs to be stored because only the changed parts are recorded.

[0052] For each annotation operation, the incremental data \D_n\ is added to the existing incremental data set.

[0053] Convolutional Neural Network (CNN) optimizes compression effect:

[0054] CNN model training: Use a large amount of labeled image data to train the convolutional neural network model to learn to maintain image quality during compression. During the training process, the input data is the uncompressed image and its corresponding compressed image, and the goal is to minimize the loss between compression and reconstruction.

[0055] The loss function can be defined as the mean square error (MSE) between the original image \I\ and the reconstructed image \\hat{I}\: $$\text{MSE}=\frac{1}{N}\sum_{i=1}^{N}(I_i-\hat{I}_i)^2$$where \N\ is the total number of pixels, \I_i\ and \\hat{I}_i\ are the original and reconstructed values ​​of the \i\th pixel, respectively.

[0056] Compression and reconstruction: Use the trained CNN model to compress and reconstruct the incremental data to improve the compression effect and image quality.

[0057] Assume that the input image is \I\, the compressed data is \C\, and the reconstructed image after the CNN decoder is \\hat{I}\, then: $$C=\text{CNN}{\text{Encoder}}(I)$$$$\hat{I}=\text{CNN}{\text{Decoder}}(C)$$

[0058] Edge computing processing: Perform preliminary processing and compression of data on edge devices to reduce the burden on central servers and improve system response speed.

[0059] Preliminary processing and compression are performed on edge devices close to the data source, which can reduce latency and quickly respond to the labeler's operational needs.

[0060] Through these steps, the labeled data can be differentially compressed effectively, and the compression effect can be optimized through the convolutional neural network (CNN) to ensure that the image quality is maintained during the compression process. At the same time, combined with edge computing technology, efficient data processing and system response can be achieved.

[0061] Specifically, the preset size loading data rules and preloading data rules include complexity trade-offs based on the content of unlabeled image data. The loading rules are adjusted based on the complexity of the image content to improve loading efficiency and annotation accuracy. A deep learning model (such as a convolutional neural network CNN) is used to predict the operation path of the annotator, and the preloading strategy is dynamically adjusted based on this, thereby improving loading efficiency and annotation accuracy. The specific implementation method includes: through an image complexity evaluation module, an algorithm (such as HOG features, LBP features, etc.) is used to extract the texture and edge features of the image and calculate the complexity score of the image. Based on the complexity score, an adaptive loading algorithm is used to dynamically adjust the amount of loaded data to ensure that high-complexity images are loaded first. A convolutional neural network (CNN) training model is used to predict the annotator's future operation path based on its historical operation data, and the preloading strategy is dynamically adjusted. Combined with the LSTM (long short-term memory network) model, the accuracy of the operation path prediction is further improved to ensure the efficiency of the preloading strategy.

[0062] “Specifically, the preset size loading data rules and preloading data rules include a complexity trade-off based on the content of unlabeled image data. The loading rules are adjusted based on the complexity of the image content to improve loading efficiency and annotation accuracy. A deep learning model (such as a convolutional neural network CNN) is used to predict the operation path of the annotator, and the preloading strategy is dynamically adjusted based on this to improve loading efficiency and annotation accuracy. The specific implementation method includes: using an image complexity evaluation module, using algorithms (such as HOG features, LBP features, etc.) to extract the texture and edge features of the image, and calculating the complexity score of the image. Based on the complexity score, an adaptive loading algorithm is used to dynamically adjust the image. The amount of data loaded ensures that high-complexity images are loaded first. The convolutional neural network (CNN) training model is used to predict the future operation path of the annotator based on the operation history data, and the preloading strategy is adjusted dynamically. Combined with the LSTM (Long Short-Term Memory Network) model, the accuracy of the operation path prediction is further improved to ensure the efficiency of the preloading strategy. "In the technology, how to achieve "through the image complexity evaluation module, use algorithms (such as HOG features, LBP features, etc.) to extract the texture and edge features of the image and calculate the complexity score of the image. Based on the complexity score, an adaptive loading algorithm is used to dynamically adjust the amount of loaded data to ensure that high-complexity images are loaded first"

[0063] To use algorithms (such as HOG features, LBP features, etc.) to extract the texture and edge features of an image and calculate the complexity score of the image through the image complexity evaluation module, and dynamically adjust the amount of loaded data based on the complexity score using an adaptive loading algorithm, you can follow the steps below:

[0064] 1. Image complexity evaluation

[0065] 1.1 Extracting HOG features

[0066] HOG (Histogram of Oriented Gradients) feature is a feature descriptor commonly used in image processing. It describes the texture and shape information of an image by calculating the directional histogram of gradients in the image.

[0067] step:

[0068] Convert the image to grayscale.

[0069] Calculate the gradient magnitude and direction for each pixel.

[0070] The image is divided into several units, and the gradient direction histogram of each unit is calculated.

[0071] Combine the histograms of each cell into a feature vector.

[0072] Formula: $$G_x=I(x+1,y)-I(x-1,y)$$

[0073] $$G_y=I(x,y+1)-I(x,y-1)$$

[0074] $$\theta=\arctan\left(\frac{G_y}{G_x}\right)$$$$H=\sum_{i=1}^{N}\text{histogram}(\theta_i)$$

[0075] Among them, \G_x\ and \G_y\ are the gradients in the horizontal and vertical directions respectively, \\theta\ is the gradient direction, and \H\ is the gradient direction histogram.

[0076] 1.2 Extracting LBP features

[0077] The LBP (Local Binary Patterns) feature is an operator that describes local texture. It generates a binary pattern by comparing the grayscale values ​​of a pixel with its neighboring pixels, thereby describing the texture characteristics of the image.

[0078] step:

[0079] Select the center pixel and compare its grayscale value with the surrounding pixels.

[0080] If the grayscale value of the surrounding pixels is greater than that of the central pixel, it is recorded as 1; otherwise, it is recorded as 0.

[0081] Convert the binary pattern to a decimal number as the feature value.

[0082] Formula: $$\text{LBP}P,R=\sum{p=0}^{P-1}s(g_p-g_c)\cdot 2^p$$

[0083] Where \s(x)\ is the sign function: $$s(x)=\begin{cases}1&\text{if}x\geq 0\\0&\text{if}x<0\end{cases}$$

[0084] \g_c\ is the gray value of the central pixel, \g_p\ is the gray value of the surrounding pixels, \P\ is the number of neighborhood pixels, and \R\ is the radius of the neighborhood.

[0085] 2. Calculate the image complexity score

[0086] The extracted HOG features and LBP features are combined to calculate the comprehensive complexity score of the image.

[0087] Formula: $$C=\alpha\cdot H+\beta\cdot E$$Wherein, \C\ is the image complexity score, \H\ is the HOG feature, \E\ is the LBP feature, \\alpha\ and \\beta\ are the feature weight parameters.

[0088] 3. Adaptive loading algorithm

[0089] Based on the complexity score, an adaptive loading algorithm is used to dynamically adjust the amount of loaded data to ensure that high-complexity images are loaded first.

[0090] step:

[0091] Compute a complexity score for each image.

[0092] Adjust the loading priority and data size of each image based on the complexity score.

[0093] High-complexity images are loaded first and allocated more loading resources.

[0094] Formula: $$L=L_{\max}\times\left(1-\frac{C}{C_{\max}}\right)$$Wherein, \L\ is the adjusted amount of loaded data, \L_{\max}\ is the maximum amount of loaded data, \C\ is the current image complexity score, and \C_{\max}\ is the maximum value of the image complexity score.

[0095] 4. Deep Learning Model

[0096] The convolutional neural network (CNN) model is used to train the model, predict the annotator’s future operation path based on his / her historical operation data, and dynamically adjust the preloading strategy.

[0097] step:

[0098] Collect the labelers’ operation history data and create a training set.

[0099] Design and train CNN models to predict the labeler's operation path.

[0100] Use the trained CNN model to predict and adjust the preloading strategy in real time.

[0101] 5. LSTM Model

[0102] Combined with the LSTM (Long Short-Term Memory Network) model, the accuracy of operation path prediction can be further improved to ensure the efficiency of the preloading strategy.

[0103] Specifically, multi-threading technology is used in the preloading process. The use of multi-threading technology significantly improves the preloading speed and reduces the labeling waiting time. The specific implementation method includes: using thread pool technology to manage multi-threading, using a fixed-size thread pool, and dynamically allocating the number of threads according to system resources. Implementing asynchronous IO operations in each thread to avoid thread blocking and improve resource utilization efficiency. Dynamically allocate preloading tasks through load balancing algorithms (such as polling scheduling algorithms, shortest task first algorithms, etc.) to ensure load balancing of each thread. Using task queue technology, put the preloading task into the task queue, and the threads in the thread pool obtain and execute it on demand. During the task execution process, lock mechanisms (such as read-write locks and mutex locks) are used in combination to protect shared resources to avoid thread competition and deadlock problems. This method significantly improves the preloading speed and reduces the labeling waiting time through the combination of multi-threading technology and load balancing algorithms; using thread pools and asynchronous IO technologies optimizes resource utilization and improves system performance and stability.

[0104] Specifically, when the annotation page is rendered, the operation path of the annotator is predicted in advance and the corresponding data is preloaded. The operation path of the annotator is predicted and preloaded, which improves the fluency and efficiency of the annotation process. Augmented reality (AR) technology is used to provide real-time image annotation guidance to help annotators complete tasks more quickly and accurately. The specific implementation method includes: using deep learning models (such as convolutional neural networks CNN and LSTM models) to train the operation history of the annotator and predict their future operation paths. Through reinforcement learning algorithms (such as Q-learning), the operation path prediction model is continuously optimized during the annotation process to improve the prediction accuracy. When the annotation page is rendered, augmented reality (AR) technology is combined to provide real-time visual and auditory prompts to guide the annotator's operation. Real-time annotation information and guidance are displayed through AR devices (such as smart glasses) to reduce the cognitive load of the annotator and improve operation efficiency. Computer vision technology is used to detect the operation behavior of the annotator in real time, compare it with the predicted path, and dynamically adjust the preloading strategy. Large-scale annotation data is processed and stored through a cloud computing platform, and combined with edge computing technology, operation requests are quickly responded to and processed on local devices. The specific method of real-time detection of the labeler's operation behavior is as follows: use a camera and a computer vision algorithm to detect the labeler's operation behavior in real time.

[0105] Algorithms: such as object detection (YOLO, FasterR-CNN) and pose estimation (OpenPose).

[0106] Formula (YOLO): $$\text{Confidence}=\text{Pr}(Object)\times\text{IOU}_{pred}^{truth}$$Where, \\text{Pr}(Object)\ is the probability of the existence of the target, and \\text{IOU}_{pred}^{truth}\ is the intersection and union ratio of the predicted box and the true box.

[0107] Specifically, the network environment of the annotator is monitored in real time during the preloading process, and the preloading strategy is adjusted dynamically according to the network environment. The network environment is monitored in real time and the preloading strategy is adjusted to ensure the best loading experience under different network conditions. The specific implementation method includes: using the network monitoring module and using SNMP (Simple Network Management Protocol) to collect key indicators such as network bandwidth, delay, and packet loss rate in real time. The real-time mean and variance of the network bandwidth are calculated by the sliding window algorithm to dynamically evaluate the stability of the current network environment. The amount of preloaded data is dynamically adjusted according to changes in the network environment using an adaptive bandwidth adjustment algorithm. For example, when the bandwidth is sufficient, the amount of preloaded data is increased; when the bandwidth is insufficient, the amount of preloaded data is reduced to avoid network congestion. Combined with reinforcement learning algorithms (such as Q-learning), the adjustment strategy is continuously optimized during the actual preloading process to select the optimal amount of preloaded data. During the execution of the preloading task, a distributed task scheduling system (such as Apache Kafka) is used to coordinate the preloading tasks under different devices and network environments to ensure reasonable task allocation and efficient execution. Through real-time monitoring and adjustment, and by adopting multi-path transmission protocols (such as MPTCP), multiple network paths can be used for data transmission simultaneously in a multi-network environment to improve data transmission efficiency and reliability.

[0108] A computer device is also disclosed, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor implements the image preloading method when executing the computer program. The computer device integrated with the preloading method improves the overall system performance and user experience.

[0109] A computer-readable storage medium is also disclosed, on which a computer program is stored, and when the computer program is executed by a processor, the image preloading method is implemented. The convenient deployment and use of the preloading method is realized through the computer-readable storage medium, which improves the usability and adaptability of the system. Through multimodal data fusion, combined with image, text and sound data, more comprehensive annotation support is provided, which improves the comprehensiveness and accuracy of the annotation process.

[0110] In some embodiments, the computer readable storage medium may be a memory such as FRAM, ROM, PROM, EPROM, EEPROM, flash memory, magnetic surface memory, optical disk, or CD-ROM; or various devices including one or any combination of the above memories. The computer may be various computing devices including intelligent terminals and servers.

[0111] In some embodiments, executable instructions may be in the form of a program, software, software module, script or code, written in any form of programming language (including compiled or interpreted languages, or declarative or procedural languages), and may be deployed in any form, including as a stand-alone program or as a module, component, subroutine or other unit suitable for use in a computing environment.

[0112] As an example, executable instructions may, but need not, correspond to a file in a file system, may be stored as part of a file that stores other programs or data, such as in one or more scripts in a HyperText Markup Language (HTML) document, in a single file dedicated to the program in question, or in multiple coordinated files (e.g., files storing one or more modules, subroutines, or code portions).

[0113] By way of example, executable instructions may be deployed to be executed on one computing device, or on multiple computing devices located at one site, or on multiple computing devices distributed across multiple sites and interconnected by a communication network.

[0114] It should be noted that, in this article, the terms "include", "comprises" or any other variations thereof are intended to cover non-exclusive inclusion, so that a process, method, article or system including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, article or system. In the absence of further restrictions, an element defined by the sentence "comprises a ..." does not exclude the existence of other identical elements in the process, method, article or system including the element.

[0115] The serial numbers of the above-mentioned embodiments of the present application are for description only and do not represent the advantages or disadvantages of the embodiments.

[0116] Through the description of the above implementation methods, those skilled in the art can clearly understand that the above-mentioned embodiment methods can be implemented by means of software plus a necessary general hardware platform, and of course by hardware, but in many cases the former is a better implementation method. Based on such an understanding, the technical solution of the present application, or the part that contributes to the prior art, can be embodied in the form of a software product, which is stored in a storage medium (such as a read-only memory / random access memory, a magnetic disk, or an optical disk), and includes a number of instructions for enabling a multimedia terminal device (which can be a mobile phone, a computer, a television receiver, or a network device, etc.) to execute the methods described in each embodiment of the present application.

[0117] The above are only preferred embodiments of the present application, and are not intended to limit the patent scope of the present application. Any equivalent structure or equivalent process transformation made using the contents of the present application specification and drawings, or directly or indirectly applied in other related technical fields, are also included in the patent protection scope of the present application.

Claims

1. A method for preloading pictures based on image annotation, characterized in that: Includes steps: Setting a size threshold for unlabeled data packets, and when the size threshold is reached, packetizing is performed in a preset manner and matching the loading data rule and preloading data rule of the preset size; Load unlabeled data on the labeling page and render it, and receive labeling information; After identifying the annotation information, preload data is loaded in the undisplayed area of ​​the annotation page; The preloaded data is rendered when the loading page becomes the marked page display area.

2. The image preloading method based on image annotation according to claim 1, characterized in that: The preloading data rule includes preloading data based on annotation history information.

3. The image preloading method based on image annotation according to claim 1, characterized in that: When the loading page changes to the marked page display area, the preloaded data is dynamically adjusted before rendering to adapt to changes in network bandwidth.

4. The image preloading method based on image annotation according to claim 1, characterized in that: The method also includes the step of compressing the labeled data to save storage space.

5. The image preloading method based on image annotation according to claim 1, characterized in that: The preset size loading data rule and preloading data rule include a complexity tradeoff based on the content of the unlabeled image data.

6. The image preloading method based on image annotation according to claim 1, characterized in that: Multithreading technology is used during the preloading process.

7. The image preloading method based on image annotation according to claim 1, characterized in that: When the annotation page is rendered, the annotator's operation path is predicted in advance and the corresponding data is preloaded.

8. The image preloading method based on image annotation according to claim 3 is characterized in that: During the preloading process, the network environment of the annotator is monitored in real time, and the preloading strategy is dynamically adjusted according to the network environment.

9. A computer device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that: When the processor executes the computer program, the image preloading method according to any one of claims 1 to 8 is implemented.

10. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores a computer program, and when the computer program is executed by a processor, the image preloading method according to any one of claims 1 to 8 is implemented.

Images