Efficient design drawing processing method and system

Abstract

The invention relates to the technical field of design drawing processing, in particular to an efficient design drawing processing method and system. The method comprises the steps of obtaining a design drawing; identifying primitives, blocks and layers in the design drawing; primitives, blocks and layers in the design drawing are converted into references; propagating the reference update to a corresponding reference position based on an update propagation algorithm; extracting a specific layer in the design drawing, and converting the specific layer into an independent drawing; storing the updated drawing based on an incremental storage mechanism; and performing parallel access and editing on the stored design drawings based on a concurrent access mechanism. And through an incremental storage technology, data redundancy is reduced, and the storage efficiency is improved.

Description

Technical Field

[0001] The present invention relates to the technical field of design drawing processing, and in particular to an efficient design drawing processing method and system. Background Art

[0002] In the engineering design and construction industries, the processing and management of design drawings is an important and complex task. Traditional design drawing processing methods usually involve a large amount of data duplication and storage, which not only takes up a lot of storage space, but also reduces the efficiency of design adjustment and collaborative work. In addition, traditional drawing processing methods have obvious limitations in achieving rapid design adjustment and collaboration. Summary of the invention In order to solve the above-mentioned problems, the present invention provides an efficient design drawing processing method and system.

[0003] In a first aspect, the present invention provides an efficient design drawing processing method, which adopts the following technical solution: An efficient design drawing processing method, comprising: Get design drawings; Identify the elements, blocks and layers in the design drawings; Convert the elements, blocks and layers in the design drawings into references respectively; Based on the update propagation algorithm, the reference update is propagated to the corresponding reference location; Extract specific layers from design drawings and convert them into independent drawings; Store updated drawings based on incremental storage mechanism; The stored design drawings are accessed and edited in parallel based on the concurrent access mechanism.

[0004] Furthermore, the identification of graphics elements, blocks and layers in the design drawings includes extracting basic geometric elements from the design drawings using geometric principles, matching blocks composed of multiple graphics elements in the design drawings with defined blocks by detecting them, and classifying graphics elements and blocks into corresponding layers by parsing layer information of the drawings.

[0005] Furthermore, the graphics elements, blocks and layers in the design drawings are converted into references respectively, including assigning a unique identifier to each graphics element and calling it at the reference position in the drawing; defining a combination of multiple graphics elements as a block and assigning a unique ID to each block; storing the content of each layer separately, assigning a unique ID to the layer definition, and pointing to the specific layer content through reference when referencing the layer.

[0006] Furthermore, based on the update propagation algorithm, the reference update is propagated to the corresponding reference location, including constructing a reference dependency graph for representing the relationship between the reference object and the object that references it; recursively traversing the dependency graph to propagate the updated reference to all referenced locations.

[0007] Furthermore, the extraction of a specific layer in the design drawing and converting the specific layer into an independent drawing includes extracting the elements on the specified layer separately based on the layer separation technology, and generating an independent drawing containing only the layer. Each layer usually contains a specific category of design elements to form an independent drawing.

[0008] Furthermore, the updated drawings are stored based on an incremental storage mechanism, including performing incremental data detection when a reference is changed, and applying incremental data only to objects that reference the reference.

[0009] Furthermore, the stored design drawings are accessed and edited in parallel based on the concurrent access mechanism, including initializing the access process through the concurrent control mechanism to ensure that the operation of each process is reasonably managed, and then controlling the access rights to the drawings based on optimistic concurrency control, pessimistic concurrency control and conflict resolution mechanisms.

[0010] In a second aspect, an efficient design drawing processing system includes: The data acquisition module is configured to acquire the design drawings; The recognition module is configured to recognize the graphic elements, blocks and layers in the design drawing; The conversion module is configured to convert the graphic elements, blocks and layers in the design drawings into references respectively; An update module, configured to propagate the reference update to the corresponding reference location based on an update propagation algorithm; The extraction module is configured to extract a specific layer in the design drawing and convert the specific layer into an independent drawing; The storage module is configured to store the updated drawings based on an incremental storage mechanism; The access module is configured to perform parallel access and editing on the stored design drawings based on a concurrent access mechanism.

[0011] In a third aspect, the present invention provides a computer-readable storage medium storing a plurality of instructions, wherein the instructions are suitable for being loaded and executed by a processor of a terminal device, for example, to describe an efficient design drawing processing method.

[0012] In a fourth aspect, the present invention provides a terminal device comprising a processor and a computer-readable storage medium, wherein the processor is used to implement various instructions; the computer-readable storage medium is used to store multiple instructions, and the instructions are suitable for being loaded by the processor and executing the described efficient design drawing processing method.

[0013] In summary, the present invention has the following beneficial technical effects: 1. Improve storage efficiency: Through incremental storage technology, data redundancy is reduced and storage efficiency is improved.

[0014] 2. Enhance design flexibility: Converting graphics elements, blocks, and layers into references improves design flexibility and ease of adjustment.

[0015] 3. Optimize collaborative work: Through the collaborative work platform, the collaborative workflow of design drawings is optimized and the efficiency of collaborative work is improved. BRIEF DESCRIPTION OF THE DRAWINGS

[0016] Figure 1 is a schematic diagram of an efficient design drawing processing method according to Embodiment 1 of the present invention; Figure 2 It is a schematic diagram of the structure of the differential tree of embodiment 1 of the present invention. DETAILED DESCRIPTION

[0017] The present invention is further described in detail below in conjunction with the accompanying drawings.

[0018] Example 1 Reference Figure 1 , an efficient design drawing processing method of this embodiment includes: Get design drawings; Identify the elements, blocks and layers in the design drawings; Convert the elements, blocks and layers in the design drawings into references respectively; Based on the update propagation algorithm, the reference update is propagated to the corresponding reference location; Extract specific layers from design drawings and convert them into independent drawings; Store updated drawings based on incremental storage mechanism; The stored design drawings are accessed and edited in parallel based on the concurrent access mechanism.

[0019] Specifically, the following steps are included: S1. Obtain design drawings.

[0020] S2. Identify entities, blocks, and layers in design drawings.

[0021] These include: (1) Recognition of graphic elements Primitives are the basic units that make up design drawings, including lines, circles, arcs, polygons, etc. The main goal of primitive recognition is to extract these basic geometric elements from drawing data.

[0022] Geometric feature extraction: Use geometric principles to analyze the vector data in the drawing file, and identify the geometric properties of each element (such as coordinates, size, angle, radius, etc.) by parsing the drawing format (such as DXF, DWG, etc.). For example: Line: a straight line between two point coordinates. Circle: center coordinates and radius. Arc: center, radius, start and end angles.

[0023] Topological structure analysis: By analyzing the topological relationships between primitives (such as adjacent, intersecting, parallel, etc.), more complex structures or combined primitives can be identified. For example, when multiple line segments are closed, they may be identified as a polygon.

[0024] Implementation steps: 1. Read the structured data of the drawing file format (such as DXF, DWG).

[0025] 2. According to different primitive types, extract their corresponding geometric properties (coordinates, length, radius, etc.).

[0026] 3. Store the extracted graphic element information as a reference object to facilitate subsequent reference and update propagation.

[0027] (2) Tile recognition A block is a group of elements in a drawing, usually representing reusable modular design elements (such as doors, windows, furniture, etc.). Block recognition is done by detecting these combined structures in the design drawings and matching or creating them with defined blocks.

[0028] Grouping structure identification: In drawing data, blocks are usually composed of multiple entities and are represented by specific identifiers (such as block definitions). When parsing the drawing format, the boundaries and constituent entities of the block can be determined by parsing these identifiers.

[0029] Similarity matching: Use graphic matching algorithms to detect repeated graphic structures in design drawings and identify them as blocks. For example, use the invariance of translation, rotation, and scaling of graphics to identify repeated modules in drawings. Reference structure analysis: In CAD software, blocks are referenced multiple times through the block reference mechanism. By analyzing these reference relationships, block instances in different locations can be identified without having to store the data of the same block repeatedly.

[0030] Implementation steps: 1. Parse the block definition part in the drawing and extract the definition and constituent elements of the block.

[0031] 2. Identify the instance position of blocks in the drawing and their transformation (such as translation, rotation, scaling, etc.) through reference relationships.

[0032] 3. Store the block's definition and instantiation information as an updateable reference.

[0033] (3) Layer identification Layers are an organizational method in design drawings, used to manage different types of elements and blocks in layers. Each layer may represent specific information, such as structure, pipeline, equipment, etc.

[0034] Hierarchical organization: Drawing file formats usually contain the definition of layers, and each element or block is assigned to a specific layer. By parsing the layer information of the drawing file, the elements or blocks can be classified into the corresponding layers.

[0035] Attribute association: Layers usually have specific attributes, such as color, line type, visibility, etc. By reading these attributes, the purpose and classification of the layer can be identified and optimized. Layers may also be used for different functional designs (such as architecture, structure, electromechanical, etc.).

[0036] Implementation steps: 1. Parse the layer definition in the drawing file and obtain the attribute information of each layer.

[0037] 2. Identify the layer to which each element or tile belongs and classify it.

[0038] 3. Extract specific layers or combine multiple layers to facilitate the generation of specific views or independent storage.

[0039] (4) Overall implementation logic File parsing: Extract metadata of entities, blocks, and layers (such as the layer and block definition part of DXF, or the object part of DWG) from the design file to generate a data model.

[0040] Data modeling: Model primitives, tiles, and layers to form independently operable data structures, each with a unique identifier and attributes.

[0041] Dynamic reference: Through the reference mechanism, each primitive and tile can reference its layer or other tile instances to achieve modularization and reuse.

[0042] Reference Updates: Based on these references, when any element, block, or layer is updated, the propagation algorithm automatically updates these changes to all references to maintain consistency.

[0043] S3. Convert entities, blocks, and layers into references.

[0044] Among them, (1) the primitive is converted into a reference Primitives are the basic building blocks in a design drawing, such as lines, circles, text, etc. The process of converting primitives into references is to assign a unique identifier (ID) to each primitive and call it using the identifier at the reference location in the drawing.

[0045] Step: Assign unique IDs to primitives: As you process each primitive, generate a unique identifier for it. Primitive A (the line) is assigned the ID Primitive_001.

[0046] Reference entity reference: When inserting or referencing the entity in a drawing, the complete entity data is not stored, but its ID is referenced.

[0047] Update propagation: When a primitive needs to be modified, you only need to update the definition of Primitive_001, and all places that reference the primitive will be automatically updated.

[0048] (2) Convert blocks to references A block is a combination of multiple primitives, usually used to insert the same object (such as doors, windows, furniture, etc.) multiple times in a design drawing. When a block is converted to a reference, similar to the primitive conversion, the system defines the block and assigns a unique ID to the block, so that multiple places can share the same block.

[0049] Steps: Define blocks: Define multiple elements as a block and assign a unique ID to the block. For example, block B (containing a line and a circle) is assigned an ID of Block_001.

[0050] Reference block reference: When referencing a block in a drawing, the detailed contents of the block are not copied, only the block ID and reference location are stored.

[0051] Modify blocks: When the definition of a block needs to be modified, update the definition of Block_001, and all references to the block will be automatically updated.

[0052] (3) Convert layer to reference Layers are logical groupings of design drawings, usually used to distinguish different types of content (such as structure, equipment, circuit, etc.). When converting a layer to a reference, the system will store the content of each layer separately and assign a unique ID to the layer definition. When referencing a layer, the reference points to the specific layer content.

[0053] Steps: Define layers: Separate the layer content in the design drawing and store it as independent layer data, assigning a unique ID. For example: Layer C (including wall design) is assigned an ID of Layer_001.

[0054] Reference layer reference: When referencing a layer in a drawing, directly reference the layer's ID instead of copying the layer's contents.

[0055] Modify the layer: If some parts of the layer need to be modified, the system will update the definition of Layer_001, and all places that reference this layer will be updated synchronously.

[0056] S4. Based on the update propagation algorithm, propagate the reference update to the corresponding reference location; First, (1) update the basic principle of the propagation algorithm: The core goal of the update propagation algorithm is to achieve reference consistency in the design drawings, that is, when a reference object changes, all references to the object can correctly reflect the latest status. This can be achieved through the following principles: Dependency analysis: First, it is necessary to clarify which objects are referenced and which are referers, so as to establish a reference dependency graph. Incremental update: Only the modified reference objects and their related parts need to be updated, without recalculating all the contents. Concurrency control: When multiple users or processes modify a reference object at the same time, the system needs to use a locking mechanism or version control mechanism to ensure the order and consistency of the updates.

[0057] (2) Steps of updating the propagation algorithm 2.1 Building a reference dependency graph In a design drawing, each element, block or layer may be referenced by other objects. Therefore, you first need to build a reference dependency graph, which is used to represent the relationship between the reference object and the object that references it.

[0058] Node: The nodes of the dependency graph represent the reference objects in the design drawing, such as elements, blocks or layers.

[0059] Edge: An edge represents a reference relationship. If object A references object B, then there will be an edge from A to B in the graph, indicating that A depends on the state of B.

[0060] Implementation steps: 1. Traverse all the elements, blocks and layers in the design drawing and analyze the reference relationship of each object.

[0061] 2. Construct a directed graph, with each reference object and its referee as a node, and establish edges through the reference relationship.

[0062] Data structure: Graph = {Node_1: [Node_2, Node_3], Node_2: [Node_4], ...}, where Node represents the reference object and the contents in the list represent the objects that reference these references.

[0063] 2.2 Reference Update Detection When a reference object (such as an element, block, or layer) in a design drawing changes, the system needs to detect the update event of the reference and determine the scope to which the update needs to be propagated.

[0064] Implementation steps: 1. Monitor update events: By monitoring the modification operations of primitives, blocks, and layers in the system, update propagation is triggered when there are changes.

[0065] 2. Mark nodes to be updated: In the reference dependency graph, mark the modified node and all its references as pending update. For example, if Node_B is updated, then mark Node_A (the node that references Node_B) as also needing to be updated.

[0066] 2.3 Calculation process of update propagation Based on the reference dependency graph, update propagation can be done by breadth-first search (BFS) or depth-first search (DFS). The goal is to recursively traverse the dependency graph and propagate the updated reference to all locations that reference it.

[0067] Implementation steps: 1. Initialize the update queue: Add the reference nodes to be modified (such as primitives, blocks or layers) to the update queue.

[0068] Initialization: Queue = [Modified_Node].

[0069] 2. Traverse the dependency graph: Take out nodes one by one from the update queue and propagate the update of the node to all objects that reference it: Take a node current_node from the queue.

[0070] Get the referrer of this node (that is, all nodes in the dependency graph that point to current_node).

[0071] Update the status of these referers and add them to the update queue.

[0072] 3. Update operation: Perform specific update operations on each referencer, such as recalculating the properties of the referenced entities, blocks, or layers to ensure that all referenced objects reflect the latest reference status.

[0073] Code: def propagate_update(graph, modified_node): queue = [modified_node] # Initialize the update queue visited = set() # Record updated nodes while queue: current_node = queue.pop(0) # Remove the current node if current_node in visited: continue visited.add(current_node) # Get all objects that reference the current node for referencing_node in graph.get(current_node, []): # Execute specific update logic (such as recalculating reference content) update_referencing_node(referencing_node) queue.append(referencing_node) #Add the referrer to the update queue.

[0074] S5. Extract a specific layer from the design drawing and convert the specific layer into an independent drawing; separate the specific layer from the main drawing of the design drawing based on the layer separation technology to form an independent drawing.

[0075] Among them, (1) the basic principle of layer separation technology The core idea of ​​layer separation technology is to extract the elements on a specified layer based on the layer structure in the design drawing and generate an independent drawing containing only that layer. Each layer usually contains a specific category of design elements, such as building plans, structural frames or electrical lines. By separating these elements, they can be viewed, edited and operated independently.

[0076] Layer: Design drawings usually consist of multiple layers, each layer represents different design information. Layers have independent properties, such as line type, color, visibility, etc.

[0077] Layer separation: extract all the elements or blocks of a specific layer in the main drawing from the entire design to form a new sub-drawing. This sub-drawing only contains the content of the extracted layer, but not the information of other layers.

[0078] Maintain references: During the separation process, the association between elements, blocks and other related reference objects needs to be maintained to ensure that the independent drawings can continue to reference the necessary data in the master drawing.

[0079] (2) Steps for layer separation 2.1 Analyze the main drawing First, the system needs to parse the main design drawing and identify all the layers contained therein and their related elements, blocks, and attributes.

[0080] step: 1. Read design drawing files: parse the file format of the main design drawing (such as DXF, DWG, etc.), read the hierarchical structure of the drawing, including the information of all layers, primitives and blocks.

[0081] 2. Get layer information: Extract the name and properties (color, line type, visibility, etc.) of each layer, as well as all the entities and blocks contained in each layer from the metadata of the drawing file.

[0082] 2.2 Extracting the content of a specific layer Once the main drawing is parsed, the next step is to extract all the contents (elements, blocks) on the specific layer selected by the user.

[0083] step: 1. Select the target layer: According to user input or pre-defined logic, specify the layer to be separated. For example, extract the building structure layer or the electrical system layer.

[0084] 2. Extract primitives and blocks: Extract all primitives (such as lines, circles, arcs, etc.) and blocks from the target layer. Store and manage these layer information independently: 2.3 Generate independent drawings Integrate the extracted primitives and block data into a new drawing file to generate an independent sub-drawing.

[0085] step: 1. Create a new drawing file: Generate a new drawing structure in the system, keeping the same format and standard as the original design drawing (such as keeping the same coordinate system, scale, etc.), but only containing the content of the selected layer.

[0086] 2. Maintain master drawing association: If the target layer contains blocks or reference objects that are associated with other layers, you need to maintain these reference relationships. For example, a block may reference objects on other layers. When generating independent drawings, you need to ensure that these references remain valid.

[0087] 2.4 Remove the influence of other layers When generating independent drawings, ensure that all elements not related to other layers are filtered out and only the data of the target layer is retained. This includes: 1. Layer filtering: In the new drawing, remove all entities, blocks, and attributes of non-target layers.

[0088] 2. Update view settings: If the drawing has view windows or layouts, these settings need to be updated to ensure that the view only shows the extracted layers and does not contain information from other layers.

[0089] 2.5 Exporting independent drawings Save the newly generated drawing file as an independent file or format for users to view or further edit. This independent drawing can be used to make separate design modifications or managed as a subset of the main drawing.

[0090] 3. Key steps in the calculation process Layer extraction logic: Use the layer identifier in the CAD file format to find and extract the graphics and blocks of the target layer. Usually each graphics and block will have a layer attribute, and the system will filter according to the attribute to form the content of an independent drawing.

[0091] Geometry transformation: During the extraction process, ensure that all geometric objects (such as lines, arcs, blocks, etc.) maintain the coordinate system consistency relative to the main drawing to avoid coordinate system offset or error caused by drawing separation.

[0092] Reference management: If there are reference relationships in the drawings (such as blocks referencing the content of other layers), these references need to be retained in independent drawings to ensure the integrity of the design content.

[0093] S6. storing the updated drawings based on the incremental storage mechanism; During the update process, in order to avoid re-storing or updating the entire drawing, an incremental storage mechanism is used. That is, only the changed parts are recorded, and the data is updated based on these increments during the update.

[0094] 1. Incremental data detection: When a reference changes, the system only records the changed part (such as element properties, block content, etc.) without the need to re-store the entire drawing.

[0095] 2. Incremental data application: When updating the propagation, it is only necessary to apply the incremental data to the objects that refer to the reference, without completely reconstructing the referenced objects.

[0096] Among them, incremental data is stored and managed through differential trees and version graphs.

[0097] 1. The principle of differential tree The differential tree is an incremental data storage technology based on a tree structure. It forms a tree structure by recording the differences (differences) between different versions of drawings or data. Each node represents a version of the design drawing, and the edges between nodes represent the changes made to the version relative to the previous version.

[0098] Key concepts of difference trees: Node: represents a version of a design drawing.

[0099] Edge: represents the change from one version to the next (incremental data), and only records the modified part.

[0100] Root node: represents the complete drawing of the initial version.

[0101] Leaf node: represents the latest drawing version.

[0102] Steps for differential tree storage: 1. Initial version creation: The first version of the drawing is used as the root node to store complete drawing data.

[0103] 2. Incremental data storage: Each time a drawing is modified, a new node is created to store only the difference data relative to the previous version (such as modified layers or blocks).

[0104] 3. Query or restore: The system recovers any version of the drawing by recursively obtaining differential data from the root node along the path.

[0105] Example of a difference tree: 1. Initial version: Version v1 of the drawing contains 3 layers: v1 is stored as the root node of the difference tree and contains the complete data.

[0106] 2. Version 2 incremental modification: Layer_2 (electrical plan) was modified based on v1.

[0107] v2 only stores the modified contents of Layer_2, and the differential tree links the v2 nodes to v1.

[0108] Version 3 incremental changes: Added Layer_4 and modified Layer_3 based on v2.

[0109] v3 stores Layer_3 and the newly added Layer_4 as child nodes of v2.

[0110] The difference tree structure is as follows Figure 2 shown.

[0111] To query or restore a version: Restore version v3: Recursively read the path v1 -> v2 -> v3, merge the differences and restore the complete drawing.

[0112] S7. Perform parallel access and editing on the stored design drawings based on the concurrent access mechanism.

[0113] The basic principle of concurrent access mechanism In the drawing processing system, concurrent access means that multiple users or processes access or modify different parts or the same part of the same drawing at the same time. The core goal of the concurrent access mechanism is to prevent data conflicts and ensure the validity of modifications. Its working principle relies on the following key technologies: Optimistic concurrency control: Assuming that conflicts occur less frequently, multiple users are allowed to read drawings at the same time, and conflicts are checked when changes are submitted, and only processed when conflicts occur.

[0114] Pessimistic concurrency control: Assuming that conflicts occur frequently, by locking the part of the drawing that needs to be modified at the beginning of the modification, prevent other users from performing parallel operations until the modification is completed.

[0115] Lock mechanism: Use read-write locks to coordinate access rights of multiple users or processes to drawings to ensure data consistency.

[0116] Version control: The version number will be updated every time the drawing is modified. The user needs to ensure that the drawing version currently being edited is consistent with the stored version to avoid overwriting other users' modifications.

[0117] Conflict resolution mechanism: When multiple users submit changes, if a conflict is detected, the system will prompt the user to manually resolve it or automatically merge it.

[0118] 2. Steps of concurrent access mechanism 2.1 Initialization of concurrent access When accessing design drawings in parallel, it is first necessary to initialize the access process through the concurrency control mechanism to ensure that the operations of each user or process are properly managed.

[0119] step: 1. Read drawing data: Multiple users or processes can read the same drawing from the database or file system at the same time. This is a parallel read operation and usually does not require locking.

[0120] 2. Version check: When the user starts editing a drawing, the system will record the version number (or timestamp) of the current drawing to ensure that the user makes modifications based on the correct version.

[0121] 2.2 Optimistic Control Flow for Concurrent Editing In scenarios where multiple users are allowed to edit drawings simultaneously, optimistic concurrency control assumes that most edits will not conflict and therefore does not enforce locking of drawing access.

[0122] step: Parallel editing: Users can freely edit based on the current drawing version, and the system will not prevent other users from modifying different parts of the drawing at the same time.

[0123] Submit changes: When user A or B completes the changes and is ready to submit, the system checks whether the version of the drawing they edited is consistent with the stored version.

[0124] Conflict detection: If another user (such as user B) has submitted changes before user A submits, the system will detect the inconsistency in the version numbers and trigger the conflict resolution mechanism.

[0125] 2.3 Pessimistic Control Flow for Concurrent Editing When frequent modifications are involved to the same drawing part, pessimistic concurrency control can be used to avoid conflicts through locking mechanisms.

[0126] step: 1. Get a lock: Before editing, users need to lock the part of the drawing they are modifying to prevent other users from editing it at the same time. Locks can be fine-grained (such as for a single layer or element) or coarse-grained (such as locking the entire drawing).

[0127] 2. Execute edit: After obtaining the lock, the user can edit the specified part. At this time, other users can only read but not modify the part until the lock is released.

[0128] 3. Submit and unlock: After user A completes the editing and submits the changes, the system releases the lock of the layer and allows other users to make changes.

[0129] 2.4 Conflict Resolution Mechanism When multiple users submit changes during concurrent editing, conflicts are inevitable. The system needs to provide a conflict detection and resolution mechanism.

[0130] step: 1. Detect conflicts: The system checks the version number to confirm whether the version submitted by the user is the latest version. If the version number does not match, it means that another user has modified the same part of the drawing, and the system will detect a conflict.

[0131] 2. Prompt the user of conflicts: The system notifies the user of conflicts and provides solutions. The user can choose to merge the changes manually or automatically merge based on the system's suggestions.

[0132] 3. Automatic merging: The system automatically merges non-conflicting parts according to the preset merging rules, or prompts the user to manually merge conflicting parts. If it is a simple geometric primitive or block, the system can automatically merge it according to the timestamp or operation priority.

[0133] 2.5 Version Management in Concurrency Control Each time a drawing is modified, the system automatically generates a new version number (or snapshot) for the drawing and ensures that the drawing versions accessed by all users are consistent.

[0134] step: 1. Version number update: When the user submits a modification, the system will update the version number of the drawing or create a new snapshot to ensure that the drawings in the system are always up to date.

[0135] 2. Version rollback: In some cases, if a modification is inappropriate or you need to return to a historical version, the system allows users to roll back to the previous drawing version.

[0136] As a further embodiment, This embodiment is also based on a reference linking mechanism to ensure reference consistency and accuracy, where: 1. Basic principles of the reference link mechanism The main function of the reference link mechanism is to connect multiple drawings or layers through references, so that different design elements can share information. The basic principles of this mechanism include the following points: Reference path: In a design drawing, a certain element, block or layer can be referenced by other objects, and these references are connected through a unique reference path. For example, a block may be referenced in multiple layers, and its modification needs to be synchronized to all layers that reference it.

[0137] Reference object identification: Each referenced object has a unique identifier (ID) that is used to locate and manage the position of the object in the drawing.

[0138] Update notification mechanism: When a reference object changes, all locations that reference the object are notified through the reference path and identifier to ensure that these locations can receive the latest updates.

[0139] 2. Refer to the steps of the link mechanism 2.1 Identification and registration of reference objects In the reference link mechanism, each referenced object (such as an element, block, or layer) is assigned a unique identifier when it is created and registered in the drawing system. This identifier is used to uniquely identify the object in multiple drawings or layers.

[0140] step: 1. Create a unique identifier: When a primitive, block, or layer is created, the system automatically assigns it a globally unique identifier (GUID).

[0141] 2. Register reference objects: Register the created objects and their identifiers in the reference management table of the drawing system, and record the type, layer, location, and properties of the object.

[0142] 2.2 Establishing reference link relationship During the design process, different drawings or layers need to share information through link references. For example, a block is referenced in multiple places in a drawing, and these reference relationships need to be managed through a reference link mechanism.

[0143] step: 1. Create a reference link: When an object (such as a block) is referenced, the system will record the reference path and the identifier of the referencer in the drawing.

[0144] Manage reference relationships: Each referenced object needs to maintain a reference list to record all the places that reference it. Through this reference list, you can track the reference relationship of each object and ensure that all referees can be found when updating.

[0145] 2.3 Reference update detection and notification When a reference object (such as an element, block, or layer) is modified, the system needs to notify all locations that reference the object through the reference link mechanism to ensure that the contents of these locations can be automatically updated.

[0146] step: 1. Monitor changes in reference objects: The system continuously monitors changes to reference objects in drawings (such as modification, deletion, etc.). Once a reference object changes, an update notification mechanism is triggered.

[0147] 2. Traverse the reference relationship: Find all places that reference the object (i.e., referees) by referring to the management table, and send update notifications to these referees.

[0148] 2.4 Apply updates and maintain consistency When an update notification is received, the referencer (such as a layer or block) needs to synchronize its referenced content to ensure that the latest state of the referenced object is applied. This step ensures that the referenced content is consistent and accurate everywhere.

[0149] step: 1. Get updated content: After receiving the update notification, the referencer obtains the latest status of the modified reference object from the master drawing, including its geometric information, properties, etc.

[0150] 2. Update referenced content: The referencer applies these updates and modifies the referenced content. At this point, the referencer's drawing content will automatically be updated to the latest status.

[0151] Example 2 This embodiment provides an efficient design drawing processing system, including: The data acquisition module is configured to acquire the design drawings; The recognition module is configured to recognize the graphic elements, blocks and layers in the design drawing; The conversion module is configured to convert the graphic elements, blocks and layers in the design drawings into references respectively; An update module, configured to propagate the reference update to the corresponding reference location based on an update propagation algorithm; The extraction module is configured to extract a specific layer in the design drawing and convert the specific layer into an independent drawing; The storage module is configured to store the updated drawings based on an incremental storage mechanism; The access module is configured to perform parallel access and editing on the stored design drawings based on a concurrent access mechanism.

[0152] A computer-readable storage medium stores a plurality of instructions, wherein the instructions are suitable for being loaded and executed by a processor of a terminal device for the efficient design drawing processing method.

[0153] A terminal device includes a processor and a computer-readable storage medium, wherein the processor is used to implement various instructions; the computer-readable storage medium is used to store multiple instructions, and the instructions are suitable for being loaded and executed by the processor to implement an efficient design drawing processing method.

[0154] The above are all preferred embodiments of the present invention, and are not intended to limit the protection scope of the present invention. Therefore, any equivalent changes made based on the structure, shape, and principle of the present invention should be included in the protection scope of the present invention.

Claims

1. An efficient design drawing processing method, characterized in that: include: Get design drawings; Identify the elements, blocks and layers in the design drawings; Convert the elements, blocks and layers in the design drawings into references respectively; Based on the update propagation algorithm, the reference update is propagated to the corresponding reference location; Extract specific layers from design drawings and convert them into independent drawings; Store updated drawings based on incremental storage mechanism; The stored design drawings are accessed and edited in parallel based on the concurrent access mechanism.

2. According to the efficient design drawing processing method of claim 1, it is characterized in that: The identification of graphics elements, blocks and layers in the design drawings includes extracting basic geometric elements from the design drawings using geometric principles, matching blocks composed of multiple graphics elements in the design drawings with defined blocks by detecting them, and classifying graphics elements and blocks into corresponding layers by parsing the layer information of the drawings.

3. According to the efficient design drawing processing method of claim 2, it is characterized in that: The steps of converting the graphic elements, blocks and layers in the design drawings into references respectively include assigning a unique identifier to each graphic element and calling the graphic element using the identifier at the reference position in the drawing; defining a combination of multiple graphic elements as a block and assigning a unique ID to each block; The content of each layer is stored separately, and a unique ID is assigned to the layer definition. When referencing a layer, the specific layer content is pointed to by reference.

4. According to the efficient design drawing processing method of claim 3, it is characterized in that: The update propagation algorithm based on the reference is used to propagate the reference update to the corresponding reference location, including constructing a reference dependency graph for representing the relationship between the reference object and the object that references it; recursively traversing the dependency graph to propagate the updated reference to all referenced locations.

5. According to the efficient design drawing processing method of claim 4, it is characterized in that: The method of extracting a specific layer from a design drawing and converting the specific layer into an independent drawing includes extracting the elements on a specified layer separately based on a layer separation technology and generating an independent drawing containing only the layer. Each layer usually contains a specific category of design elements to form an independent drawing.

6. The efficient design drawing processing method according to claim 5 is characterized in that: The updated drawings are stored based on the incremental storage mechanism, including performing incremental data detection when a reference is changed, and applying the incremental data only to the objects that reference the reference.

7. The efficient design drawing processing method according to claim 6 is characterized in that: The concurrent access mechanism based on the stored design drawings is used to perform parallel access and editing, including initializing the access process through a concurrent control mechanism to ensure that the operation of each process is reasonably managed, and then controlling the access rights to the drawings based on optimistic concurrency control, pessimistic concurrency control and conflict resolution mechanisms.

8. An efficient design drawing processing system, characterized in that: include: The data acquisition module is configured to acquire the design drawings; The recognition module is configured to recognize the graphic elements, blocks and layers in the design drawing; The conversion module is configured to convert the graphic elements, blocks and layers in the design drawings into references respectively; An update module, configured to propagate the reference update to the corresponding reference location based on an update propagation algorithm; The extraction module is configured to extract a specific layer in the design drawing and convert the specific layer into an independent drawing; The storage module is configured to store the updated drawings based on an incremental storage mechanism; The access module is configured to perform parallel access and editing on the stored design drawings based on a concurrent access mechanism.

9. A computer-readable storage medium storing a plurality of instructions, characterized in that: The instructions are suitable for being loaded by a processor of a terminal device and executing the method according to claim 1 .

10. A terminal device, comprising a processor and a computer-readable storage medium, wherein the processor is used to implement each instruction; and the computer-readable storage medium is used to store multiple instructions, characterized in that: The instructions are suitable for being loaded by a processor and executing the method as claimed in claim 1 .

Images