CN115953564A - Component ordered marking method based on dynamo - Google Patents
Component ordered marking method based on dynamo Download PDFInfo
- Publication number
- CN115953564A CN115953564A CN202310224384.4A CN202310224384A CN115953564A CN 115953564 A CN115953564 A CN 115953564A CN 202310224384 A CN202310224384 A CN 202310224384A CN 115953564 A CN115953564 A CN 115953564A
- Authority
- CN
- China
- Prior art keywords
- node
- component
- input end
- primitive
- value
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
Images
Classifications
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02P—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN THE PRODUCTION OR PROCESSING OF GOODS
- Y02P90/00—Enabling technologies with a potential contribution to greenhouse gas [GHG] emissions mitigation
- Y02P90/30—Computing systems specially adapted for manufacturing
Landscapes
- Processing Or Creating Images (AREA)
Abstract
The disclosure relates to a component ordered marking method based on dynamo. The method comprises the following steps: acquiring a three-dimensional BIM model with distributed components; acquiring each component graphic primitive in the three-dimensional BIM by utilizing a dynamo program; sequencing all component primitives in a first direction and a second direction on a plane where the component primitives are located; determining the mark content of each sorted component element; adding a mark to each component according to the mark content to form a two-dimensional mark graph; the program is compiled in advance by using dynamo language, the dynamo language program has the characteristic of visualization, the programming efficiency is improved, the operation of a user is facilitated, the automatic sorting on the plane of the member according to the BIM three-dimensional model of the member is realized, and a mark is arranged for each member, the mark content can comprise the serial number of the member, and the further analysis and statistics work on the member is facilitated.
Description
Technical Field
The disclosure relates to the technical field of BIM, in particular to a component ordered marking method based on dynamo.
Background
Under the large background of accelerating the development of building industrialization in China, the production and cutting of building components such as curtain walls, heat-insulating plates, ceramic tiles and the like begin to be close to industrial processing. For the convenience of factory processing, the building components are orderly marked in the BIM three-dimensional model of the target building according to the position information of the building components arranged in a matrix to form a two-dimensional marking drawing. In the related technology, each component is orderly marked and a two-dimensional marking graph is drawn manually, so that the efficiency is low and the error rate is high.
Disclosure of Invention
To overcome the problems in the related art, the present disclosure provides a dynamo-based component order labeling method to solve the above problems.
According to a first aspect of embodiments of the present disclosure, there is provided a dynamo-based component order labeling method, the method comprising:
acquiring a three-dimensional BIM model with distributed components;
acquiring each component graphic primitive in the three-dimensional BIM by utilizing a dynamo program;
sorting all the component primitives in a first direction and a second direction on a plane;
determining the mark content of each component element after sequencing by using an element.
Adding a mark for each component according to the mark content by using a tag node, wherein ByElementAndLocation node forms a two-dimensional mark graph;
the element input end of the element.SetParameterByName node inputs the sorted component primitive list; inputting a number at the ParameterName input end; the Value input end inputs the set format, wherein the format comprises the following steps: number of characters, connector.
In one embodiment, sorting all the component primitives in a first direction and a second direction on a plane comprises:
sorting all the component primitives in a first direction to obtain a plurality of different rows;
in each row, sorting each member graphic element in the row in the second direction;
sorting all the component primitives in a first direction to obtain a plurality of different rows, including:
determining a maximum area first outer surface of each member primitive using vector. Specifically, the output terminal of the vector.z node is connected with = = the input terminal at the x terminal of the node, the y input terminal of the = node is set to-1, and = = the output terminal of the node outputs the first outer surface with the largest area and the vector value of-1;
determining parameters of a central point of the first outer surface of each component primitive by using a surface.PointAtParameter node, wherein the parameters of a u end and a v end of the surface.PointAtParameter node are set to be 0.5;
determining a center point Z coordinate of the first outer surface by using a point.Z node;
sorting the Z coordinates of the central point of the first outer surface by using a List (list. SortByKey node) to obtain a Z coordinate list;
grouping the Z coordinate list according to Z coordinate values by using List.GroupByKey nodes to obtain a plurality of groups;
the key input end of the List.GroupByKey node is connected with the sorted key output end of the List.SortByKey node;
the list input end of the List.GroupByKey node is connected with the sortedlist output end of the List.SortByKey node;
with each group as a row.
In one embodiment, before the step of sorting the Z coordinates of the center point of the outer surface of each building element by using the ListSortByKey node to obtain a plurality of different Z coordinates, the method further comprises: carrying out reduction processing and rounding processing on the Z coordinate,
the method specifically comprises the following steps: realizing Z coordinate reduction processing by using a first CodeBlock node; setting a ratio value in the node; the input end of the first CodeBlock node is connected with the output end of the Point.Z node;
rounding the reduced Z coordinate by using a Math.round node; and the input end of the Math.round node is connected with the output end of the first CodeBlock node.
In one embodiment, sorting each of the component primitives in each row in the second direction comprises:
determining the central point of each component primitive by utilizing solid.centroid nodes in each component primitive in the same row group;
acquiring an X coordinate value of the central point of each component graphic primitive by using a point.X node;
acquiring a Y coordinate value of the central point of each component graphic element by using a point.Y node;
sorting each building element according to the value of X and/or Y by using a second ListSortByKey node;
and the key input end of the second ListSortByKey node is connected with the output end of the first CodeBlock.
In one embodiment, sorting each of the architected primitives by the values of X and Y using the second ListSortByKey node comprises:
the method comprises the steps that a second CodeBlocek node is used for achieving addition operation of an X value and a Y value, wherein an n input end of the second CodeBlocek node is connected with an output end of a point.X node; the m input end is connected with the output end of the point.Y node; the calculation formula is set as: m + n; the output end of the second CodeBlocek node is connected with the input end of the second ListSortByKey node.
In one embodiment, the Value input inputs the set format, including:
setting a connector and a left part character and a right part character of the connector by using a third CodeBlock node;
the output end of the third CodeBlock node is connected with the Value input end;
the first input end of the third CodeBlock node sets the left part; the second input end is set to the right part;
for the left part characters, determining a character string of the name of each component primitive and the number of deleted characters in the name by using a first string.remove node; and the number of spaces before the first character to the left of the name;
wherein, the name of each component primitive is obtained by utilizing element.
In one embodiment, for the right-side part characters, the number of each building element primitive and the width of each numbered string are determined using the first string.
Determining the number of the components by using the Count node;
sequencing the number according to a preset sequence by utilizing a fourth CodeBlock node to obtain the serial number of each component; the number is input to a str input of the first string.
The input end of the fourth CodeBlock node is connected with the output end of the Count node;
and the newWidth input end of the first String. PadLeft node inputs the width value of the character string.
In one embodiment, the tagging of each component according to the tag content by using the tag.
Inputting the marked position information by using a location input end of a tag.
Determining a center point of the marker using a ZK.BoundingBox.CenterPoint node;
the output end of the ZK.BoundingBox.CenterPoint node is connected with the input end of the tag.ByElementAndLocation node location.
In one embodiment, the method further comprises:
screening out target component primitives by adopting a Filter.
The value input end of the Filter.Byname node inputs name keywords of a target component primitive;
and setting a rule of screening as 'including' at a rule type input end of the Filter.
In one embodiment, the method further comprises:
determining the marking type of each component according to the size of the component, and specifically comprising the following steps:
screening out component primitives of a type of standard component and component primitives of a non-standard component, wherein the length and the width of the component primitives are equal to the standard value, and the component primitives of the type of standard component are screened out by using & & node, first = = node and second = = node;
setting the type of a component primitive of the standard component as a standard component by adopting a first changefamily type node;
a standard component type identifier is input into a type input end of the first changefamily type node; the Element input end is connected with the in output end of a List.FilterByBoolMask node;
the mask input end of the List.FilterByBoolMask node is connected with the node output end; the list input end inputs all the mark lists of the component graphic primitives;
setting the type of a component primitive of the nonstandard component as a nonstandard component by adopting a second changefamily type node;
inputting a nonstandard component type identifier at a type input end of the second changefamily type node; the input end of the Element is connected with the out output end of the List.
Wherein, the first = = node is used for screening out the first type component primitive with length smaller than the length standard value;
the second = = node is used for screening out a second component primitive with the width smaller than a width standard value;
the & & node is used for taking intersection of the first type component primitive and the second type component primitive;
the first = = node inputs standard width value at y input; the width value of each component primitive is input by an x input end;
the second = = node y input standard length value; inputting the length value of each component primitive by an x input end;
determining a width value of each component primitive by adopting a first element. Wherein, the input value of the parameter name input end of the element.
An output of a first element.getparametervaluebyname node is connected to an x input of the first = = node;
determining a length value of each component primitive by adopting a second element. Wherein the parameterName node input value of the second element. Getparametervaluebyname node is length;
the output of the second element.getparametervaluebyname node is connected to the x input of the second = = node.
The technical scheme provided by the embodiment of the disclosure can have the following beneficial effects: the method of the application utilizes dynamo language to pre-program, the dynamo language program has the characteristic of visualization, the programming efficiency is improved, the operation is convenient for a user, the two-dimensional layout is automatically generated according to the three-dimensional model of the BIM of the component, each component is provided with a mark, the mark content can comprise the serial number of the component, and the further analysis and statistics work of the component is facilitated.
It is to be understood that both the foregoing general description and the following detailed description are exemplary and explanatory only and are not restrictive of the disclosure.
Drawings
The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments consistent with the present disclosure and, together with the description, serve to explain the principles of the disclosure.
FIG. 1 is a flow diagram illustrating a dynamo-based component order labeling method in accordance with an exemplary embodiment;
FIG. 2 is a schematic illustration of a two-dimensional distribution of a component shown in accordance with an exemplary embodiment;
FIG. 3 is a dynamo program diagram illustrating primitive ordering in accordance with an exemplary embodiment;
FIG. 4 is a dynamo program diagram illustrating another primitive ordering according to an example embodiment;
FIG. 5 is a dynamo program diagram illustrating one format setting in accordance with an exemplary embodiment;
FIG. 6 is a dynamo program diagram illustrating one flag setting in accordance with an exemplary embodiment;
FIG. 7 is a dynamo program diagram illustrating one type of flag according to an example embodiment.
Detailed Description
Reference will now be made in detail to the exemplary embodiments, examples of which are illustrated in the accompanying drawings. When the following description refers to the accompanying drawings, like numbers in different drawings represent the same or similar elements unless otherwise indicated. The implementations described in the exemplary embodiments below are not intended to represent all implementations consistent with the present disclosure. Rather, they are merely examples of apparatus and methods consistent with certain aspects of the present disclosure, as detailed in the appended claims.
It should be noted that all actions of acquiring signals, information or data in the present application are performed under the premise of complying with the corresponding data protection regulation policy of the country of the location and obtaining the authorization given by the owner of the corresponding device.
The application provides a component order marking method based on dynamo, and refers to a flow chart of the component order marking method based on dynamo shown in figure 1; the method may comprise the steps of:
in step S102, a three-dimensional BIM model of the distributed arrangement of the members is obtained.
In this embodiment, the member may include a heat-insulating plate, a curtain wall, a tile, etc. The BIM three-dimensional model diagram of the target wall surface of the target building with the distributed components can be obtained in advance. In the BIM three-dimensional model diagram, a plurality of members are distributed and arranged on a target wall surface.
In step S104, each component primitive in the three-dimensional BIM model is obtained by using dynamo program.
In this embodiment, a dynamo program may be programmed in advance, and each component primitive in the three-dimensional BIM model may be obtained by using the dynamo program.
In step S106, all the building blocks are sorted in the first direction and the second direction on the plane where the building blocks are located.
In this embodiment, a dynamo program may be pre-programmed, and all the component primitives are sorted in the horizontal and vertical directions on the plane, so as to obtain a two-dimensional distribution map.
In step S108, the element.
Wherein, the marking content may include: the number of the facade wall on which the component is located, and the number of the component in the facade wall.
In step S110, a tag is added to each component according to the tag content by using a tag.
The element input end of the element.SetParameterByName node inputs the sorted component primitive list; inputting a number at the ParameterName input end; the Value input end inputs the set format, wherein the format comprises the following steps: number of characters, connector.
Illustratively, the components are labeled: LM01-030, LM01 being the number of the vertical wall, -being the connector, the number of characters is 4, the number of characters representing the left side of the connector is 4. 030 is the number of the member in the facade wall.
Referring to fig. 2, a two-dimensional distribution diagram of a member in which a two-dimensional distribution map is generated according to the arrangement positions of the members in a three-dimensional model and a mark is generated for each member is shown.
The method of the application utilizes dynamo language to pre-program, the dynamo language program has the characteristic of visualization, the programming efficiency is improved, the operation is convenient for a user, the two-dimensional layout is generated according to the three-dimensional model of the component, and each component is provided with a mark, so that the further analysis and statistics work of the component is facilitated.
In one embodiment, in step S106, sorting all the building blocks in the first direction and the second direction on the plane may further include the following steps:
sorting all the component primitives in a first direction to obtain a plurality of different rows; in each row, each of the component primitives in the row is sorted in the second direction.
Referring to the dynamo program diagram for primitive ordering shown in fig. 3-4, the first direction ordering of all component primitives results in a plurality of different rows, including:
determining a maximum area first outer surface of each member primitive using vector. Specifically, the output terminal of the vector.z node is connected with = = the x input terminal of the node, and = the y input terminal of the node is set to-1, and = = the output terminal of the node outputs the first outer surface of the largest area with the vector value of-1.
Illustratively, referring to fig. 3, a polysurface surface node is further provided before the above-mentioned vector.z node, for obtaining all the entire curved surfaces of each component.
Determining parameters of a center point of the first outer surface of each component primitive using a surface pointantparameter node, wherein parameters of u and v ends of the surface pointantparameter node are set to 0.5. And determining the coordinate of the center point Z of the first outer surface by utilizing the point.
And sequencing the Z coordinates of the central point of the first outer surface by using a List.
Grouping the Z coordinate list according to the Z coordinate value by using List.GroupByKey nodes to obtain a plurality of groups.
The key input end of the List.GroupByKey node is connected with the sorted key output end of the List.SortByKey node.
The list input end of the List.GroupByKey node is connected with the sorted list output end of the List.SortByKey node. With each group as a row.
In order to eliminate omission phenomenon caused by error of Z coordinate, referring to fig. 4, in an embodiment, before sorting the Z coordinate of the center point of the outer surface of each component primitive by using a ListSortByKey node to obtain a plurality of different Z coordinates, performing reduction processing and rounding processing on the Z coordinate, specifically including: the first CodeBlock node is used for realizing Z coordinate reduction processing; setting a ratio value in the node; the input end of the first CodeBlock node is connected with the output end of the Point.
Rounding the reduced Z coordinate by using a Math.round node; and the input end of the Math.round node is connected with the output end of the first CodeBlock node.
For example, nine members in a row of ten members each having a Z coordinate of 1400 mm may be grouped together in a single row. However, the tenth member may have a Z-coordinate of 1450 mm due to a placement error in the three-dimensional model, and if considered in terms of a simple Z-coordinate, the tenth member will not be listed in the same row as described above, resulting in omission.
Therefore, in the method of the present application, the Z coordinate may be subjected to a reduction process, and when the reduction process is performed, the ratio may be set to 0.01, the Z coordinate may be changed to 14.5, and the Z coordinate may be further subjected to zero removal and rounding by a math. In this way, omissions can be avoided. Of course, the above proportional value may be flexibly set to other values.
In one embodiment, referring to fig. 4, in each row, sorting each member primitive in the row in the second direction comprises:
determining the central point of each component primitive by utilizing a solid.
Acquiring an X coordinate value of the central point of each component graphic primitive by using a point.X node;
acquiring a Y coordinate value of the central point of each component graphic element by using a point.Y node;
sorting each building element according to the value of X and/or Y by using a second ListSortByKey node;
and the key input end of the second ListSortByKey node is connected with the output end of the first CodeBlock.
In one embodiment, each of the fabric primitives may be sorted by the value of X using a second ListSortByKey node. In such an embodiment, the Y value is the same for each member and the X value is different. That is, the facade wall on which the component is arranged is horizontally and transversely arranged, and the facade wall is parallel to the X axis.
In one embodiment, each of the architected primitives may be sorted by the value of Y using a second ListSortByKey node. In such an embodiment, the X value is the same for each member, but the Y value is different. That is, the facade wall on which the members are located is vertically and longitudinally arranged, and the facade wall is parallel to the Y axis.
In some embodiments, referring to fig. 4, sorting each building element by X and Y values using the second ListSortByKey node comprises:
the method comprises the steps that a second CodeBlocek node is used for achieving addition operation of an X value and a Y value, wherein an n input end of the second CodeBlocek node is connected with an output end of a point.X node; the m input end is connected with the output end of the point.Y node; the calculation formula is set as: m + n; the output end of the second CodeBlocek node is connected with the input end of the second ListSortByKey node. In such an embodiment, the X and Y values for each member are different. That is, the vertical wall on which the member is located is obliquely arranged. The sum of the X and Y values for each member may be calculated and may be sorted according to the sum.
In one embodiment, referring to fig. 5, the format of the value input setting includes:
setting a connector with a third CodeBlock node, and a left-side part character and a right-side part character of the connector.
And the output end of the third CodeBlock node is connected with the Value input end.
The first input end of the third CodeBlock node sets the left part; the second input terminal sets the right-hand portion.
For the left part characters, determining a character string of the name of each component primitive and the number of deleted characters in the name by using a first string.remove node; and the number of spaces before the first character to the left of the name.
The number of character strings deleted from the left side in a predetermined view name is input to the count input terminal of the first string.remove node, and the number of spaces input to the startindex input terminal may be set to 0.
Wherein, the name of each component primitive is acquired by utilizing an element.
Illustratively, the view names are: the double-layer integrated standard vacuum insulation board has the following view names if two characters are deleted: and integrating a standard vacuum insulation board.
In one embodiment, referring to fig. 5, for the right-hand side portion characters, the number of each building element and the width of each numbered string are determined using the first string. Padleft node;
the number of components is determined using the Count node.
Sequencing the number according to a preset sequence by utilizing a fourth CodeBlock node to obtain the serial number of each component; the number is input to the str input of the first string.
And the input end of the fourth CodeBlock node is connected with the output end of the Count node.
And the newWidth input end of the first String.PadLeft node inputs the width value of the character string.
Illustratively, if the number of components is 100 and the input string width at the newWidth input is 3, the components are numbered from 001 to 100.
In one embodiment, referring to fig. 6, the tagging of each component according to the tag content by using the tag.
Inputting the marked position information by using a location input end of a tag. Determining the center point of the marker by using a ZK.
The output end of the ZK, boundingBox, and CenterPoint node is connected with the input end of the Tag, byElementAndLocation node location.
Illustratively, referring to fig. 2, the position of the mark of each member is located at the center position of the member element.
In one embodiment, further comprising: screening out target component primitives by adopting a Filter. Inputting name keywords of a target component primitive by a value input end of the Filter. The rule of screening is set as 'including' by the ruletype input end of the Filter.
In this embodiment, a keyword of the name of the target component primitive may be input, for example, the keyword is set as: a vacuum plate. Byname nodes can screen out components whose names include vacuum panels, namely, screen out vacuum panels.
In one embodiment, referring to fig. 7, the determining of the type of the mark of each component according to the size of the component specifically includes:
component primitives of the type standard component, which have a length and width equal to the standard value, and component primitives of the non-standard component are screened out using & & node, first = = node, and second = = node.
Wherein the & & node is used for AND operation of two input data; the = = node is used to determine whether the data of the two inputs are equal, if so, the output is True, otherwise, false is output.
And adopting a first changefamily type node as a component primitive setting type of the standard component to be the standard component. Wherein a type input terminal of the first changefamily type node inputs a standard component type identifier. The Element input end is connected with the in output end of the List.
The mask input end of the List.FilterByBoolMask node is connected with the & node output end; the list input end inputs all the mark lists of the component primitives.
And adopting a second ChangeFamilyType node as the component primitive setting type of the nonstandard component. Wherein a type input end of the second ChangeFamilyType node inputs a nonstandard component type identifier; the Element input end is connected with the out output end of the List.
Wherein the first = = node is configured to screen out the first type component primitives with lengths smaller than the length standard value.
The second = = node is configured to screen out second type component primitives with widths smaller than width standard values.
The & & node is used for taking an intersection of the first type of component graphic elements and the second type of component graphic elements;
the first = = node inputs standard width value at y input; the x input inputs the width value of each building element.
The second = = node y input standard length value; the x input inputs the length value of each building element.
Determining a width value of each component primitive by adopting a first element. Wherein, the parameter name input end of the element.
The output of the first element.getparametervaluebyname node is connected to the x input of the first = = node.
Determining a length value of each component primitive by adopting a second element. Wherein the parameterName node input value of the second element.
The output of the second element.getparametervaluebyname node is connected to the x input of the second = = node.
Other embodiments of the disclosure will be apparent to those skilled in the art from consideration of the specification and practice of the disclosure. This application is intended to cover any variations, uses, or adaptations of the disclosure following, in general, the principles of the disclosure and including such departures from the present disclosure as come within known or customary practice within the art to which the disclosure pertains. It is intended that the specification and examples be considered as exemplary only, with a true scope and spirit of the disclosure being indicated by the following claims.
It will be understood that the present disclosure is not limited to the precise arrangements described above and shown in the drawings and that various modifications and changes may be made without departing from the scope thereof. The scope of the present disclosure is limited only by the appended claims.
Claims (10)
1. A component ordered marking method based on dynamo is characterized by comprising the following steps:
acquiring a three-dimensional BIM model with distributed components;
acquiring each component graphic primitive in the three-dimensional BIM by utilizing a dynamo program;
sorting all the component primitives in a first direction and a second direction on a plane;
determining the mark content of each sequenced component graphic element by utilizing an element.SetParameterByName node;
adding a mark for each component according to the mark content by using a tag node, wherein ByElementAndLocation node forms a two-dimensional mark graph;
the element input end of the element.SetParameterByName node inputs the sorted component primitive list; inputting a number at the ParameterName input end; the Value input end inputs the set format, wherein the format comprises the following steps: number of characters, connector.
2. A dynamo-based member ordering markup method according to claim 1 wherein ordering all member primitives in a first and second direction on a plane comprises:
sorting all the component primitives in a first direction to obtain a plurality of different rows;
in each row, sorting each member primitive in the row in a second direction;
sorting all the component primitives in a first direction to obtain a plurality of different rows, including:
determining a first outer surface of a maximum area of each component primitive using vector. Specifically, the output end of the vector.z node is connected with an input end at the x end of = node, the input end at the y end of = node is set to-1, and the output end of = node outputs a first outer surface with a maximum area and a vector value of-1;
determining parameters of a central point of the first outer surface of each component primitive by using a surface.PointAtParameter node, wherein the parameters of a u end and a v end of the surface.PointAtParameter node are set to be 0.5;
determining a center point Z coordinate of the first outer surface by using a point.Z node;
sorting the Z coordinates of the central point of the first outer surface by using a List (list. SortByKey node) to obtain a Z coordinate list;
grouping the Z coordinate list according to Z coordinate values by using List.GroupByKey nodes to obtain a plurality of groups;
the key input end of the List.GroupByKey node is connected with the sorted key output end of the List.SortByKey node;
the list input end of the List.GroupByKey node is connected with the sortedlist output end of the List.SortByKey node;
with each group as a row.
3. A dynamo-based component ordered marking method as claimed in claim 2, wherein before sorting the Z coordinate of the center point of the outer surface of each component primitive by a ListSortByKey node to obtain a plurality of different Z coordinates, further comprising: carrying out reduction processing and rounding processing on the Z coordinate,
the method specifically comprises the following steps: realizing Z coordinate reduction processing by using a first CodeBlock node; setting a ratio value in the node; the input end of the first CodeBlock node is connected with the output end of the Point.Z node;
rounding the reduced Z coordinate by using a Math.round node; and the input end of the Math.round node is connected with the output end of the first CodeBlock node.
4. A dynamo-based component order labeling method as claimed in claim 3,
in each row, sorting each member primitive in the row in a second direction, comprising:
determining the central point of each component primitive by utilizing solid.centroid nodes in each component primitive in the same row group;
acquiring an X coordinate value of the central point of each component graphic primitive by using a point.X node;
acquiring a Y coordinate value of the central point of each component graphic element by using a point.Y node;
sorting each component primitive by a second ListSortByKey node according to the value of X, and/or Y;
and the key input end of the second ListSortByKey node is connected with the output end of the first CodeBlock.
5. A dynamo-based component order labeling method as claimed in claim 4, wherein using said second ListSortByKey node to order each component primitive by X and Y values comprises:
the method comprises the steps that a second CodeBlocek node is used for achieving addition operation of an X value and a Y value, wherein an n input end of the second CodeBlocek node is connected with an output end of a point.X node; the m input end is connected with the output end of the point.Y node; the calculation formula is set as: m + n; the output end of the second CodeBlocek node is connected with the input end of the second ListSortByKey node.
6. A dynamo-based component order labeling method as claimed in claim 1,
the format of the Value input setting comprises:
setting a connector and a left part character and a right part character of the connector by using a third CodeBlock node;
the output end of the third CodeBlock node is connected with the Value input end;
the first input end of the third CodeBlock node sets the left part; the second input end is set to the right part;
for the left part characters, determining a character string of the name of each component primitive and the number of deleted characters in the name by using a first string.remove node; and the number of spaces before the first character to the left of the name;
wherein, the name of each component primitive is obtained by utilizing element.
7. A dynamo-based component order labeling method as claimed in claim 6,
for the right-side part characters, determining the number of each building element primitive and the width of each numbered character string by using a first string.PadLeft node;
determining the number of the components by using the Count node;
sequencing the number according to a preset sequence by utilizing a fourth CodeBlock node to obtain the serial number of each component; the number is input to a str input of the first string.
The input end of the fourth CodeBlock node is connected with the output end of the Count node;
and the newWidth input end of the first String.PadLeft node inputs the width value of the character string.
8. A method for the ordered labeling of dynamo-based structures according to claim 1,
and adding a mark for each component according to the mark content by using a tag, byElementAndLocation node, wherein the mark comprises the following steps:
inputting the marked position information by using a location input end of a tag.
Determining a center point of the marker using a ZK.BoundingBox.CenterPoint node;
the output end of the ZK.BoundingBox.CenterPoint node is connected with the input end of the tag.ByElementAndLocation node location.
9. A dynamo-based member ordering marking method as claimed in claim 1, further comprising:
screening out target component primitives by adopting a Filter.
Inputting name keywords of a target component primitive by a value input end of the Filter.
The rule type input end of the Filter Byname node sets the rule of screening as 'including'.
10. A dynamo-based member ordering marking method as claimed in claim 1, further comprising:
determining the mark type of each component according to the size of the component, and specifically comprising the following steps:
screening out component primitives of a type of standard component and component primitives of a non-standard component, wherein the length and the width of the component primitives are equal to the standard value, and the component primitives of the type of standard component are screened out by using & & node, first = = node and second = = node;
setting the type of a component primitive mark of the standard component as the standard component by adopting a first changefamily type node;
a standard component type identifier is input into a type input end of the first changefamily type node; the Element input end is connected with the in output end of a List.FilterByBoolMask node;
the mask input end of the List.FilterByBoolMask node is connected with the & node output end; the list input end inputs all the mark lists of the component graphic primitives;
setting the type of the component primitive mark of the nonstandard component as a nonstandard component by adopting a second changefamily type node as the component primitive mark of the nonstandard component;
inputting a nonstandard component type identifier at a type input end of the second changefamily type node; the Element input end is connected with the out output end of the List.FilterByBoolMask node;
wherein, the first = = node is used for screening out the first type component primitive with length smaller than the length standard value;
the second = = node is used for screening out a second component primitive with the width smaller than a width standard value;
the & & node is used for taking intersection of the first type component primitive and the second type component primitive;
the first = = node inputs standard width value at y input; inputting the width value of each component primitive by an x input end;
the second = = node y input standard length value; inputting the length value of each component primitive by an x input end;
determining a width value of each component primitive by adopting a first element. Wherein, the input value of the parameter name input end of the element, getParameterValueByname node is the width;
the output of the first element.getparametervaluebyname node is connected to the x input of the first = = node;
determining a length value of each component primitive by adopting a second element. Wherein the parameterName node input value of the second element. Getparametervaluebyname node is length;
the output of the second element.getparametervaluebyname node is connected to the x input of the second = = node.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310224384.4A CN115953564B (en) | 2023-03-10 | 2023-03-10 | Component ordered marking method based on dynamo |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202310224384.4A CN115953564B (en) | 2023-03-10 | 2023-03-10 | Component ordered marking method based on dynamo |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN115953564A true CN115953564A (en) | 2023-04-11 |
| CN115953564B CN115953564B (en) | 2023-06-02 |
Family
ID=85896231
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202310224384.4A Active CN115953564B (en) | 2023-03-10 | 2023-03-10 | Component ordered marking method based on dynamo |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN115953564B (en) |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20090094007A1 (en) * | 2007-10-04 | 2009-04-09 | Hiroyuki Konno | System for defining simulation model |
| CN112417569A (en) * | 2020-12-03 | 2021-02-26 | 上海电力设计院有限公司 | Revit primitive labeling method, device, equipment and storage medium |
| CN113436331A (en) * | 2021-06-29 | 2021-09-24 | 北京住总第三开发建设有限公司 | Modeling method and device based on Dynamo |
-
2023
- 2023-03-10 CN CN202310224384.4A patent/CN115953564B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20090094007A1 (en) * | 2007-10-04 | 2009-04-09 | Hiroyuki Konno | System for defining simulation model |
| CN112417569A (en) * | 2020-12-03 | 2021-02-26 | 上海电力设计院有限公司 | Revit primitive labeling method, device, equipment and storage medium |
| CN113436331A (en) * | 2021-06-29 | 2021-09-24 | 北京住总第三开发建设有限公司 | Modeling method and device based on Dynamo |
Also Published As
| Publication number | Publication date |
|---|---|
| CN115953564B (en) | 2023-06-02 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| EP0559294B1 (en) | Method and apparatus for preparing map data with regional properties | |
| CN106123898B (en) | Indoor paths planning method based on picture parsing | |
| CN107527395A (en) | A kind of unmanned plane method for inspecting, device and unmanned plane | |
| Laycock et al. | Automatically generating large urban environments based on the footprint data of buildings | |
| CN115194931B (en) | Planning method, device and equipment for concrete 3D printing path and storage medium | |
| CN115953564A (en) | Component ordered marking method based on dynamo | |
| CN100494891C (en) | Sub-picture element level outline extracting method in photographic measurement | |
| CN115879194A (en) | Method for generating curtain wall panel number drawing and keel layout drawing based on BIM one-key | |
| CN110738596A (en) | method for importing CAD engineering graphic element into three-dimensional map | |
| CN112116713B (en) | High-precision steel bar arrangement method for linear bearing platform type components | |
| CN113850996A (en) | Road section bus line repetition coefficient data calculation method and device and storage medium | |
| CN104504206B (en) | A kind of 2.5D drags addition and the method for sequence | |
| CN105868189A (en) | Method and device for establishing spatial index of electronic map | |
| CN106199745A (en) | A kind of recognition methods of the pore throat of connection | |
| CN116090077B (en) | Composite insulation board deepening method based on BIM technology | |
| CN207424933U (en) | A kind of building element tagging system based on Building Information Model | |
| CN113496053B (en) | Intelligent layout method for bidirectional bottom ribs of multi-opening prefabricated laminated slab | |
| CN114840909B (en) | BIM automatic modeling method for hollow stone curtain wall | |
| CN116341061B (en) | Drawing generation method based on dynamo | |
| CN107993181A (en) | The faster statistical approach of AutoCAD parameter blocks | |
| CN109345607B (en) | Method for automatically marking EPC picture | |
| CN117216836B (en) | Dynamo-based gate equipment batch modeling method | |
| CN117176596B (en) | Manufacturing service supply and demand network simulation method for industrial Internet platform | |
| CN116310261B (en) | Three-dimensional model segmentation method, device, equipment and storage medium | |
| CN111046465B (en) | Intelligent construction method for special-shaped floor block-shaped decorative surface layer |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |