Dynamic control system for block arrangement based on cooperation of rhino and grasshopper

Abstract

The present application relates to the technical field of block arrangement control, in particular to a block arrangement dynamic control system based on Rhino and Grasshopper cooperation, in the present application, the block is parameterized as a topological node and a zero-spacing constraint relationship is established through a constraint network construction module, a dynamically updated network node set and a topological link relationship are generated, and the problems of structural gap in traditional arrangement and low model reconstruction efficiency are solved; a dynamic response module is based on real-time positioning of an influence node range based on an event source, generates a state event carrying a change type, realizes localized accurate conduction, and avoids resource waste of global recalculation; an integrated solving module calls three types of rules through fixed time sequence, forcibly updates position continuity by using geometric continuity rules, modifies spatial interference by using conflict-free rules, and adjusts size combination by using optimization rules, cooperatively updates node parameters, drives the interface to generate an arrangement scheme, and solves the technical problems of continuity destruction, spatial interference and high proportion of non-standard components in block design.

Description

Technical Field

[0001] This invention relates to the field of block layout control technology, specifically a dynamic control system for block layout based on the collaboration of Rhino and Grasshopper. Background Technology

[0002] Traditional Rhino+Grasshopper block layout design faces two major drawbacks: First, any local modification triggers a global model recalculation. Due to the lack of a dynamic topology network, the system cannot accurately screen affected blocks, resulting in the repeated calculation of a massive number of irrelevant node parameters (position, orientation, size, etc.), leading to serious resource waste. Second, the node parameter update process is fragmented. Position adjustment, collision avoidance, and size optimization require discrete operations, causing a disconnect between geometric continuity constraints and spatial interference detection. Multiple independent corrections increase time costs and easily introduce compliance deviations, severely restricting the real-time interaction efficiency and reliability of complex curved masonry structures. The fundamental problem lies in the lack of a precise extraction mechanism for local parameters and a chain-like collaborative update mechanism. Summary of the Invention

[0003] The purpose of this invention is to provide a dynamic control system for block arrangement based on the collaboration of Rhino and Grasshopper, in order to solve the problems mentioned in the background art. Specific technical problems include how to accurately capture the influence range of local changes in order to efficiently obtain the parameters of the node to be processed; and how to update the parameters of the node to be processed through multi-rule collaborative chaining.

[0004] To achieve the above objectives, the present invention provides the following technical solution:

[0005] This dynamic control system for block arrangement based on the collaboration of Rhino and Grasshopper includes a constraint network construction module, a dynamic response module, and an integrated solution module, wherein:

[0006] The network node set generation unit in the constraint network construction module initializes the real-time feedback constraint network in the Grasshopper environment. It deconstructs the block into nodes with position, orientation, and size. The position is determined by the coordinates of the geometric center point, the orientation is dynamically calculated by the normal vector and the surface curvature (stored as a quaternion), and the size is abstracted from the proportion of the outer envelope box. Finally, the network node set is generated. This design accurately encapsulates the physical properties of the block and provides a data carrier for real-time updates.

[0007] The topology link generation unit in the constraint network construction module filters adjacent node pairs through a distance determination algorithm (the threshold automatically scales with the block size), establishes zero-space constraint equations (such as position vector + size vector = adjacent position), forms a permanent adjacency graph (uniform grid / radial topology), and stores it as a sparse adjacency matrix as the topology link relationship; this scheme solidifies the topology dependency between nodes and provides a mathematical constraint framework for continuous maintenance.

[0008] The collaborative unit in the constrained network construction module serializes the network node set into a data tree structure, converts the topological link relationship into an adjacency matrix and an association list, and binds node parameters and topological relationships through an identifier mapping system. This design enables real-time interoperability between nodes and topological relationships, ensuring efficient access by downstream modules.

[0009] The constraint network building module is used to address the discreteness of traditional system modules. It forces adjacent nodes to have zero spacing through topological link relationships, solving the problem of layout gaps. It also uses an identifier mapping system to provide an index basis for local updates, avoiding global recalculation, and solidifies structural correlations through constraint equations, preventing continuity disruptions caused by size optimization.

[0010] The dynamic response module locates the event origin node based on the spatial index of the network node set, performs a depth-first traversal through the adjacency association list of topological links, and generates a set of affected node identifiers; the synchronous mapping Rhino operation type is change encoding; this module is used to achieve localized and accurate propagation of event impact, and ensures synchronous response of the associated node group by relying on the topological link relationship through adjacency traversal; only the subset of affected nodes is updated, thus reducing the computational load; the traversal range is dynamically configured to adapt to the complexity differences between curved and planar surfaces.

[0011] The integrated solver module invokes geometric continuity rules to group affected nodes according to the adjacency association list of topological links; it collaboratively solves zero-gap constraint equations (such as "position vector + size vector = adjacent position"), updates the position and orientation parameters of nodes within the group, and forces seamless connection of node arrangement within the group to solve gap problems.

[0012] The integrated solver module invokes conflict-free rules, using the position parameters output by the geometric continuity rules as a basis; it maps the topological link relationships into three-dimensional spatial units (each set of link nodes generates a bounding box); it detects overlap between nodes within the unit and interference between nodes and Rhino obstacles; it applies position offset vectors to the interfering nodes; the spatial units are generated based on the topological links to accurately locate the interference region; and it corrects based on the previous output to avoid disrupting the continuity results.

[0013] The integrated solver module calls optimization rules and outputs spatially compliant positions based on conflict-free rules; it extracts boundary constraints of topological link relationships (such as surface edge node groups); under the premise of ensuring zero-spacing constraints, it uses a heuristic algorithm to select the best standard size combination; the boundary constraints force the size optimization to meet the continuity requirements of the connection and reduce the generation of structural weak areas.

[0014] The integrated solver module writes back the updated position, orientation, and size parameters to the data tree nodes of the network node set through the identifier mapping system; it also synchronously refreshes the adjacency status of the topology links; and pushes the updated network node set to the input of the geometry reconstruction component through the Grasshopper data flow pipeline, with node parameter changes triggering the geometry reconstruction process in real time. The geometry reconstruction component parses the node parameters of the network node set, locates 3D coordinate points based on position parameters, calculates rotation matrices based on orientation parameters, scales standard block templates based on size parameters, and calls the entity generation method of the RhinoCommon API to reconstruct the spatial geometry of each block. Based on the reconstructed block geometry set, it drives the real-time rendering pipeline of the Grasshopper view window to generate a visual layout scheme that includes material shading and boundary rendering; the identifier system maintains topology consistency; and incremental rendering achieves millisecond-level response.

[0015] Compared with the prior art, the beneficial effects of the present invention are:

[0016] This invention dynamically encapsulates the relationship between block nodes and topology, accurately locates the influence domain of changes based on adjacency depth-first traversal, and narrows the range of node parameters to be processed to avoid global recalculation. The integrated solution module executes geometric continuity, conflict-free and optimization rules in a fixed-time chain. That is, in the first stage, the position and orientation of adjacent nodes are updated by forcing zero-distance constraints; in the second stage, spatial units are mapped to eliminate interference displacement; and in the final stage, the size is heuristically adjusted under boundary constraints. This achieves three-level collaborative updates of node parameters, improves layout efficiency and ensures the self-consistency of geometric continuity and collision avoidance. Attached Figure Description

[0017] Figure 1 This is a schematic diagram of the overall modules of the present invention;

[0018] Figure 2 This is a schematic diagram of the constraint network construction module unit of the present invention;

[0019] Figure 3 This is a flowchart illustrating the dynamic response module and integrated solution module of the present invention.

[0020] In the diagram: 100, Constraint network construction module; 101, Network node set generation unit; 102, Topology link relationship generation unit; 103, Cooperative unit; 200, Dynamic response module; 300, Integrated solution module. Detailed Implementation

[0021] The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0022] Next, please refer to Figure 1 The present invention provides a technical solution: a dynamic control system for block arrangement based on the collaboration of Rhino and Grasshopper, including a constraint network construction module 100, a dynamic response module 200 and an integrated solution module 300.

[0023] Rhino is short for Rhinoceros, an architectural CAD software used to build 3D modeling models; Grasshopper is a visual parametric design plugin for the Rhino platform that drives parametric design through data flow components.

[0024] Please see Figure 2 In the constraint network construction module 100, the network node set generation unit 101 reads the block geometry entities (including planar walls, curved structures, and irregular components) of the 3D modeling model in the Rhino platform through the geometry parsing engine in the Grasshopper environment; each block is deconstructed into a parametric node object, where:

[0025] The position parameters are determined by the three-dimensional coordinates of the block's geometric center point in the global coordinate system. In the Rhino global coordinate system, the geometric processing function of the Rhino Common API is called to perform bounding box calculations on each block entity, and the geometric center point of the bounding box is taken as the three-dimensional spatial coordinates of the block node. These coordinates are stored in the form of floating-point vectors (X, Y, and Z components correspond to the three spatial axes respectively), accurately describing the absolute position of the block in the model. This calculation process is adaptable to any block geometry (including curved walls or irregular components) and does not rely on preset reference points.

[0026] Orientation parameters are dynamically calculated based on the normal direction of the block's reference surface and the curvature of the attached surface, and the spatial rotation state is stored in quaternion form. First, the normal direction of the building surface to which the block is attached is extracted at the contact point. Second, the rotation angle of the reference surface is adjusted in combination with the rate of curvature change (calculated through surface differential geometry). Finally, the spatial rotation state is represented in quaternion form. The four components (w, x, y, z) of the quaternion avoid the Euler angle gimbal lock problem and ensure the uniqueness of orientation parameters under any surface arrangement. This parameter is updated in real time with the deformation of the surface, realizing the adaptive fitting of the block to the complex surface.

[0027] The dimensional parameters are abstracted from the length, width, and height ratio of the outer envelope box of the block; by calculating the maximum dimension vector of the outer envelope box in the local coordinate system, the scalar values ​​of length, width, and height are extracted and normalized to the scale coefficients (e.g., length:width:height = 1.0:0.5:0.3).

[0028] The parsing process invokes geometric processing methods from the RhinoCommon API, including but not limited to bounding box calculation, normal vector extraction, and projection transformation. All nodes are aggregated into a network node set according to spatial partitioning rules, organized using a hash table data structure. The key is a unique node identifier (generated based on the hash value of the block's spatial location), and the value is a composite object encapsulating position, orientation, and size. This network node set establishes a spatial index structure in memory, supporting fast retrieval of nearest neighbor nodes. The RhinoCommon API refers to the development interface library provided by Rhino.

[0029] The topology link generation unit 102 in the constraint network construction module 100 generates topology link relationships based on a dynamic constraint mechanism of geometric continuity rules, specifically including:

[0030] First, a relative distance determination algorithm is used to screen potential adjacent node pairs in the network node set (the distance threshold is automatically scaled according to the maximum size of the block). For node pairs that meet the conditions, a zero-space constraint is applied. Constraints are then established by establishing constraint equations describing the adjacent boundaries (e.g., horizontally adjacent nodes satisfy "node A position vector + node A length unit vector = node B position vector").

[0031] The constraint equations are encoded as the underlying logic of topological link relationships. The permanent adjacency relationships between nodes are represented by a graph structure, where nodes are vertices and adjacency relationships are undirected edges. A uniform grid topology is formed in regularly arranged regions, while a radial non-uniform topology is generated based on the projection of normal vectors in curved regions.

[0032] Topological links are stored in the form of a sparse adjacency matrix, where the matrix row / column indices are bound to node identifiers, and the element boolean values ​​indicate the existence of adjacencies.

[0033] The output interface of the coordination unit 103 in the constraint network construction module 100 realizes bidirectional coordination between the network node set and the topology link relationship, wherein:

[0034] The network node set is serialized into the Grasshopper native data tree structure, and the tree hierarchy is organized using a spatial partitioning strategy (dynamic partitioning based on model bounding boxes). Leaf nodes attach node parameter objects within the corresponding spatial unit.

[0035] The topological link relationships are converted into two complementary formats: one is an adjacency matrix, which stores the link states between nodes using a two-dimensional array; the other is an adjacency association list, which linearly records the identifiers of each linked node.

[0036] The output interface establishes an identifier mapping system. Each node in the data tree stores its global identifier at its mount point. This identifier serves as a direct index to the association list and is also mapped to the row and column positions in the adjacency matrix. Subsequent modules synchronously query node parameters and associated node sets through the identifiers to ensure the real-time consistency of the topological link relationships. The construction process of the identifier mapping system includes the following steps:

[0037] Based on the spatial coordinates of each node in the network node set, a globally unique identifier is calculated using a spatial location hash algorithm. Specifically, the three-dimensional coordinate values ​​are normalized and then input into a hash function to generate a fixed-length identifier.

[0038] Create a key-value mapping table to store three types of binding relationships: associate identifiers with the storage paths of leaf nodes in the data tree (path format is "regional level index + node number"); map identifiers to linear storage location numbers in the adjacency association list; and convert identifiers into row and column numbers in the adjacency matrix.

[0039] Input a node identifier, and synchronously return the data tree storage path, adjacency list index, and matrix row and column numbers; input any carrier information (such as matrix row and column numbers), and reverse locate the node identifier and associated data tree path and list index through the mapping table; real-time interoperability between node entities and topology relationship carriers is realized through the memory-resident mapping table, and the topology link relationship can be updated synchronously in real time when node parameters change, ensuring data consistency.

[0040] The dynamic response module 200 captures geometric change operations of the Rhino model in real time (including operations such as surface control point displacement, boundary line redrawing, and obstacle position updates) through the Rhino API event listener. When an event is triggered, it performs an impact range analysis based on the network node set and topology link relationship output by the constraint network construction module 100, specifically including:

[0041] First, locate the node identifier closest to the event source point in the spatial index structure of the network node set as the origin node; then, access the adjacency association list of the topological link relationship, and perform an adjacency depth-first traversal with the origin node as the root (the traversal level is dynamically configured according to the model complexity to avoid fixed values), and search for adjacent nodes that are directly or indirectly linked to the origin node layer by layer to generate a set of affected node identifiers.

[0042] Simultaneously, the Rhino operation event type is parsed and mapped to the system's internal change type code (e.g., surface deformation = 01, boundary movement = 02, etc.); finally, a standardized node state change event object is generated, whose data structure includes a set of affected node identifiers (stored as a linked list), change type code (enumeration value), and event timestamp; this event is pushed to the integrated solver module 300 through Grasshopper's data flow pipeline, and the node identifier in the event object is completely consistent with the global identifier of the network node set, ensuring the consistency of adjacency queries of topological link relationships.

[0043] After receiving the node state change event object pushed by the dynamic response module 200, the integrated solver module 300 extracts the set of affected node identifiers from the event, queries the data tree structure of the network node set based on this identifier set, and loads the corresponding node parameters (position / orientation / size) to be processed. During the rule execution phase, it strictly follows a fixed-sequence chain to call three types of rules, specifically including:

[0044] The execution of the geometric continuity rule relies on the node adjacency network established by topological links. First, based on the adjacency association list in the topological links, the nodes affected by the event are divided into multiple associated node groups (nodes within a group are forced to be adjacent through topological links). Each group of nodes is regarded as a collaborative computing unit, and the dependency relationship between position and orientation is defined by establishing a zero-space constraint equation system—for example, adjacent nodes A and B satisfy the linear constraint "position vector_A + size vector_A × orientation unit vector = position vector_B", where the orientation unit vector is determined by the rotation matrix derived from the orientation parameter. For each node group, a linear equation system consisting of all constraint equations in the group is constructed and solved (the dimension of the equation system is equal to the number of nodes in the group × degrees of freedom). The least squares iterative method is used to solve for the optimal solution of node position and orientation, so that the spacing between all adjacent nodes approaches zero. Finally, the updated position and orientation parameters are output. This process ensures the synchronous optimization of the position and orientation of nodes within the group, avoids cascading errors caused by local adjustments, and maintains the continuity requirement of the block arrangement.

[0045] The execution of conflict-free rules uses the output of geometric continuity rules as a spatial reference. After obtaining the node position parameters updated by the geometric continuity rules, the topological link relationship is mapped into a three-dimensional spatial detection mesh. Each mesh cell corresponds to a minimum bounding box composed of a set of topological link nodes (e.g., two topological link nodes generate a hexahedral bounding box). The spatial range of the mesh cell is dynamically calculated based on the node position and size parameters. Based on this mesh structure, spatial interference detection is performed: first, the overlap between nodes within the mesh cell is detected (overlap is determined if the bounding boxes of two nodes intersect); second, the preset obstacle geometry (such as pipes, equipment, etc.) in the Rhino model is retrieved, and the interference intensity is determined by calculating the spatial intersection volume between the obstacle and the node bounding box; position offset correction is applied to nodes with interference: a displacement vector is generated along the surface normal vector direction or the preset obstacle avoidance direction, and the minimum displacement is calculated using the Newton iteration method until the interference is eliminated; the corrected spatial compliance position is output. This process converts discrete nodes into spatial detection cells through topological link relationships, greatly improving the efficiency of conflict detection, while ensuring that the position correction conforms to the underlying geometric constraints.

[0046] The optimization rules operate based on the spatially compliant positions provided by the conflict-free rules, obtain the corrected position parameters of the nodes, extract boundary constraints (such as the connectivity requirements of curved edge node groups) from the topological link relationships, and perform size optimization while maintaining the zero-spacing constraint equations. The core of size adjustment is to reduce the proportion of non-standard blocks. First, a standard block size library (such as 300mm×600mm rectangular blocks) is established, and a heuristic algorithm is used to match the optimal size combination—with minimum cutting loss as the objective function, the following decision paths are traversed through the constraint propagation algorithm:

[0047] The node size parameters are matched proportionally with the standard size library; for nodes in non-standard boundary areas, the minimum cutting area scheme is calculated using boundary constraints as boundary conditions; when there are topological links between nodes in a group, size coordination constraints are applied to ensure that the dimensions at the connection are consistent (e.g., the same size is used for the arch block group); finally, the size parameters are updated and the stability of the zero-spacing constraint is verified within the framework of the topological link relationship; this process maximizes resource utilization while ensuring structural continuity.

[0048] After all parameters are updated, the modified position / orientation / size parameters are written back to the data tree nodes of the network node set through the identifier mapping system, and the adjacency status of the topology links is refreshed synchronously (only the node spatial attributes are updated, without changing the topology link structure); the updated network node set immediately drives the geometry reconstruction component of the Grasshopper interface to generate a layout scheme, where:

[0049] Data synchronization mechanism: When the network node set is updated in the integrated solver module, the system encapsulates the changed node dataset (containing only a subset of nodes affected by node state change events) into a data packet and pushes it to the input of the geometry reconstruction component through the Grasshopper parameterized component link. This process calls the data change monitoring interface, and automatically triggers the geometry reconstruction process when a node parameter change event is detected. Data transmission adopts an incremental update strategy—only the modified node parameter copies are synchronized to avoid the delay caused by full data copying, and the real-time responsiveness is controlled within millisecond latency (e.g., measured ≤50ms).

[0050] Geometry reconstruction rules: Position parameters are directly mapped to Rhino 3D coordinate points; orientation parameters (quaternion format) are used to calculate the spatial rotation matrix through a rotation matrix transformation formula; size parameters drive the affine transformation of the standard block template with scaling factors (e.g., a size parameter of 1.2 represents a template magnification of 1.2 times); finally, the solid generation method of the Rhino Common API is called to bind the coordinate points, rotation matrix, and scaling factor to the preset block template family to generate solid geometry with spatial attributes; the template family library is pre-built in the Grasshopper user environment and supports parametric instantiation of block types such as cubes / arches;

[0051] Dynamic visualization engine: The reconstructed block geometry set is injected into the rendering callback interface, driving the real-time rendering pipeline in the Grasshopper view window. Material library resources are indexed according to the block type for surface mapping. Edge enhancement technology is used to highlight the splicing gaps between blocks. The view is refreshed based on the fast rendering mechanism of the graphics processing unit to ensure smooth operation. Finally, a dynamic and controllable layout visualization model is generated, supporting interactive operations such as rotation and sectioning.

[0052] Please see Figure 3 When the Rhino model undergoes geometric changes (such as surface deformation or boundary movement), the dynamic response module 200 accurately locates the affected origin node and generates a subset of affected nodes through a depth-first adjacency traversal. This node then enters the integrated solution module 300, undergoing a three-layer chained processing: first, geometric continuity rules are applied to maintain zero-space constraints; then, spatial interference detection and correction are performed using conflict-free rules; finally, optimization rules are executed to complete size selection. The processing results are written back to the network node set through an identifier mapping system, driving Grasshopper to achieve geometric reconstruction, and finally outputting a real-time visualized layout scheme with boundary rendering. Its effects are as follows:

[0053] It can respond to model changes in a very short time, updating only the local areas affected by topological changes, avoiding the burden of traditional global recalculation; through topological link relationships and identifier mapping, it accurately ensures the error-free transmission of geometric deformation to associated nodes and the maintenance of structural continuity, and ensures that dimensional optimization does not destroy this continuity; it provides visualization of construction accuracy, and renders and highlights splicing seams in real time, enabling designers to directly verify the actual constructability of the scheme in the modeling environment; the fixed-time chain rules enforce the execution order (geometric continuity before conflict-free detection, then before optimization), eliminating the risk of structural misalignment and component collision caused by step-by-step processing.

[0054] The foregoing has shown and described the basic principles, main features, and advantages of the present invention. Those skilled in the art should understand that the present invention is not limited to the above embodiments. The embodiments and descriptions in the specification are merely preferred examples and are not intended to limit the invention. Various changes and modifications can be made to the invention without departing from its spirit and scope, and all such changes and modifications fall within the scope of the present invention as claimed. The scope of protection of the present invention is defined by the appended claims and their equivalents.

Claims

1. A dynamic control system for block layout based on the collaboration of Rhino and Grasshopper, wherein Rhino is a 3D modeling platform and Grasshopper is a visual parametric design plugin for the Rhino platform, characterized in that... It includes a constraint network building module (100), a dynamic response module (200), and an integrated solution module (300), wherein: The constraint network construction module (100) initializes a real-time feedback constraint network in the Grasshopper environment, maps the blocks to nodes containing position, orientation, and size, and forces the spacing between adjacent nodes to be zero through geometric continuity rules, forming a basic topological structure, and outputs the network node set and topological link relationships; the constraint network construction module (100) includes a topological link relationship generation unit (102), and the process of generating topological link relationships by the topological link relationship generation unit (102) specifically includes: Potential adjacent node pairs are screened using a relative distance determination algorithm, with the distance threshold automatically scaled based on the maximum size of the blocks; zero-space constraint is applied to node pairs that meet the conditions, and constraint equations describing the adjacent boundaries are established; permanent adjacency relationships between nodes are represented by a graph structure, forming a uniform grid topology or a radial non-uniform topology; it is stored as a sparse adjacency matrix, with the matrix row / column indexes bound to node identifiers to generate topological link relationships; The constrained network construction module (100) includes a coordination unit (103), which is used to realize bidirectional coordination between the network node set and the topology link relationship, specifically including: The network node set is serialized into the Grasshopper native data tree structure, and a dynamic partitioning strategy based on model bounding boxes is used to organize the tree hierarchy; the topological link relationship is converted into an adjacency matrix and an adjacency association list; an identifier mapping system is established to bind the data tree node mounting point, the adjacency association list index, and the row and column positions of the adjacency matrix. The dynamic response module (200) monitors the geometric change operation of the model in the Rhino platform in real time. Based on the network node set and topology connection relationship output by the constraint network construction module (100), it analyzes the node range affected by the event and generates a node state change event carrying the identifier of the affected node and the change type code. The integrated solution module (300) loads the parameters of the nodes to be processed into the network node set based on the node state change events, and updates the parameters of the nodes to be processed by executing three types of rules in a fixed-time chain, wherein: By invoking geometric continuity rules, the position and orientation of the node to be processed are updated; by invoking conflict-free rules, spatial interference between nodes to be processed and between the node and obstacles is detected and corrected, which is used to correct the position of the node to be processed; by invoking optimization rules, the size of the node to be processed is adjusted; and the updated node to be processed is output to the Grasshopper interface to generate a layout scheme.

2. The dynamic control system for block layout based on Rhino and Grasshopper collaboration as described in claim 1, characterized in that, The constrained network construction module (100) includes a network node set generation unit (101), and the process of generating a network node set by the network node set generation unit (101) specifically includes: The position parameter is determined by the three-dimensional coordinates of the geometric center point of the block in the global coordinate system; the orientation parameter is dynamically calculated based on the direction of the normal vector of the block's reference surface and the curvature of the attached surface, and the spatial rotation state is stored in quaternion form; the size parameter is abstracted from the length, width and height ratio of the block's outer envelope box; all nodes are aggregated into a network node set according to the spatial partitioning rules, and are organized using a hash table data structure, where the key is the unique identifier of the node and the value is a composite object encapsulating the position, orientation and size.

3. The dynamic control system for block layout based on Rhino and Grasshopper collaboration as described in claim 1, characterized in that, The process by which the dynamic response module (200) analyzes the node range affected by the event specifically includes: Locate the node identifier closest to the event source in the spatial index structure of the network node set as the origin node; access the adjacency association list of the topological link relationship and perform an adjacency depth-first traversal with the origin node as the root; generate a set of affected node identifiers, and parse the Rhino operation event type mapping into the change type code.

4. The dynamic control system for block layout based on Rhino and Grasshopper collaboration as described in claim 1, characterized in that, The process of invoking the geometric continuity rule specifically includes: The affected nodes are grouped according to the adjacency association list of topological links; the position and orientation parameters of the nodes in the group are updated collaboratively; and the updated position and orientation parameters are output by solving the zero-space constraint equations of the node group.

5. The dynamic control system for block layout based on Rhino and Grasshopper collaboration according to claim 1, characterized in that, The process of invoking the conflict-free rule specifically includes: Based on the position parameters output by the geometric continuity rule, the topological link relationship is mapped into a three-dimensional spatial unit; the overlap between nodes and the spatial interference between nodes and obstacles within the unit are detected; and a position offset vector is applied to nodes with interference.

6. The dynamic control system for block layout based on Rhino and Grasshopper collaboration according to claim 1, characterized in that, The process of invoking the optimization rules specifically includes: Based on the spatial compliance location output by the conflict-free rule; extract the boundary constraints in the topological link relationship; under the premise of ensuring zero spacing constraint, adopt a heuristic algorithm to select the standard size combination according to the minimum cutting loss objective function; update the size parameters.

7. The dynamic control system for block layout based on Rhino and Grasshopper collaboration according to claim 1, characterized in that, The integrated solver module (300) writes back the modified position, orientation, and size parameters to the data tree nodes of the network node set through the identifier mapping system; Synchronously refresh the adjacency status of the topology links; The updated network node set drives the generation and layout scheme of geometric reconstruction components in the Grasshopper interface.

8. The dynamic control system for block layout based on Rhino and Grasshopper collaboration according to claim 7, characterized in that, The process of generating the layout scheme specifically includes: The updated network node set is pushed to the input of the geometry reconstruction component through the Grasshopper data flow pipeline, and the geometry reconstruction process is triggered in real time when the node parameters change. The geometric reconstruction component parses the node parameters of the network node set, locates the three-dimensional coordinate points according to the position parameters, calculates the rotation matrix according to the orientation parameters, scales the standard block template according to the size parameters, and calls the entity generation method of the RhinoCommon API to reconstruct the spatial geometry of each block. Based on the reconstructed set of block geometry, the real-time rendering pipeline of the Grasshopper view window is driven to generate a visual layout scheme that includes material shading and boundary rendering.

Images