BentleyGenerativeComponents_08110227_徐艺源

Introduction The purpose of this section is to introduce beginners to the underlying concepts of GenerativeComponents and to offer some more conceptual background to the more experienced user. The introduction is structured from a design point of view rather than as a purely technical manual. It can be read sequentially or used as reference material on the side while working with GenerativeComponents. At the heart of the documentation is a reference guide to all available features of the software.

What is GenerativeComponents?

GenerativeComponents is an associative parametric design system that gives architects and engineers new ways to efficiently explore alternative building forms. Once the underlying logic and design relationships have been defined, the designer can create new options without manually building (or rebuilding) the detail design model for each scenario. This has a profound effect on design by encouraging an iterative search for more efficient solutions, while at the same time offering an increase in the overall efficiency of more conventional aspects of design and documentation.

GenerativeComponents captures and graphically presents both design components and abstract relationships between them. This capability lets GenerativeComponents go beyond making geometry explicit; it can capture design intent in a re‐executable form. GenerativeComponents allows designers to work completely graphically, or to combine this with scripting and programming where appropriate. In fact, the designer's own scripts can define the geometric behavior of components even when these are being manipulated in dynamics. This integration of “algorithmic design” with conventional interaction based on “direct manipulation” allows GenerativeComponents to fully support alternative approaches to design that span the intellectual and creative spectrum.

GenerativeComponents is the design tool of choice for creative architects and engineers who appreciate that design is best when it emerges from a combination of intuition and logic.

How Does GenerativeComponents Work with MicroStation?

GenerativeComponents can be thought of as a way in which existing MicroStation functionality has been repackaged to allow for complex parametric and associative design. GenerativeComponents does not produce or use any new element types that do not already exist in MicroStation. GenerativeComponents works within a standard MicroStation session. GenerativeComponents can work with existing MicroStation elements either within the current .DGN file or from references and, in turn, can create new elements either within the current .DGN file or into other associated .DGN files.

Getting Started Application Window Layout One way to start using GenerativeComponents is to model a design using the interface. The application provides several windows, toolboxes, and tools for doing so.

The three main windows available by default in GenerativeComponents are: the GenerativeComponents window, the Geometry window (named “View 1 – Top, Default” by default), and the Symbolic Diagram window. The following is a brief description of each. More details are provided in later sections.

You can move and resize the three windows to meet your needs. On dual screens or larger screens it is advisable to enlarge each of the windows as much as possible. It is important to keep all windows and toolboxes open and visible because you will use them frequently and they will help you understand the concept of parametric modeling through its parallel representation of design.

GenerativeComponents Window The GenerativeComponents window contains menus, tools, and all available feature types and update methods you can use to model a design. It also includes a Transaction File player for capturing design history. The transactions that record the instructions for constructing the geometry are stored in a transaction file that has the file extension .gct.

In the default setup, the GenerativeComponents window is docked to the left‐hand side of the application window. To switch between the list of features and the Transaction File player, click their tabs at the bottom of the window.

If you prefer a larger view of the GenerativeComponents window, click and drag its title bar to another place in the application window. Now you can resize the GenerativeComponents window. To re‐dock the GenerativeComponents window, click the window’s title bar, drag it to the left‐hand side of the application window, and drop it.

Menus The menu bar contains menus and menu items, some of which replicate the tools below it and some of which perform additional functions.

File menu – Contains menu items for creating and working with transaction files, importing and exporting to other file formats, and exiting GenerativeComponents and MicroStation.

Features menu – Contains menu items corresponding to the tools below it. See the tool descriptions below.

Toggle menu – Contains menu items corresponding to the tools below it. See the tool descriptions below.

Graph menu – Used to manage existing features and graph variables.

Tools menu – Used to create and manage user‐defined features, as well as promoting MicroStation geometry to GenerativeComponents features.

Debug menu – Used to assist in the development of GCScript code written within GenerativeComponents.

Help menu – Selecting Contents opens this help file. Selecting Show Quick Help opens the Quick Help tab in the GenerativeComponents window. Expand the window and click the Start button to see a short animation about the fundamental tools and operating methods in GenerativeComponents. Clicking About GenerativeComponents shows the software version.

Active Drawing Plane Selecting the active drawing plane allows you to pre‐select the plane that a point is associated with when placed using the Create Point tool.

Initially there are three predefined planes, which correspond with the three planes of the baseCS. Selecting them highlights the active plane in the geometric view. If additional planes are needed they can be defined using the user‐defined plane option. To select the user‐defined plane, click the plane in the Symbolic Diagram or geometric view. It is added to the list of available drawing planes.

XY Plane

YZ Plane

XZ Plane

User‐defined Plane

When a plane is placed using the shortcut tool as explained above, the result is a Point.OnPlane by X and Ytranslation associated to the active drawing plane selected from the drop‐down list.

Toolbox and Tools Below the menus is the GenerativeComponents toolbox, which contains all of the tools needed to operate GenerativeComponents.

New Transaction File

Open Transaction File

Save Transaction File

Save Transaction File As

Record User Changes in the Transaction File

Show Symbolic Diagram

Update All Graphs

Promote MicroStation Element to Feature using Element Symbology Create Feature

Create Point

Create Plane

Create Coordinate System

Move Feature

Switch Supports

Copy Feature

Mirror‐Copy Feature

Edit Feature

Delete Feature

Toggle Deferred Dynamics

Toggle Visibility

Toggle Deferred Update

Toggle Replication Style

Toggle Is Construction

Apply Active Symbology

Toggle Visibility of Construction

Toggle Visibility of Handles

Split Point

Merge Points

Create Model

Generate Feature Type

Indicates whether graph is locked or unlocked

by GenerativeComponents

New Feature tab The New Feature tab contains a library of all available feature types and update methods you can use to model a design. To choose a feature you simply click one in the Feature Type list. Update methods define how a feature is created and what its dependencies are. To choose an update method for a feature, click one in the list. Then you can provide input values for its properties.

You can extend the Feature library by creating your own feature types, by programming new feature types in C#, and by using graph functions to script them.

\

Transaction File tab The design history is a major aspect of the development of design within a parametric model. Each change and association can be recorded as a transaction step. Using such transactions, you can group multiple changes into a single, named, logical transaction.

This helps in structuring the design process. Transactions appear on the Transaction File tab.

A transaction step appears in the Transaction File player as follows.

At the bottom of the Transaction File tab are the controls for moving backwards and forward through the transaction steps.

The Transaction File tab shows an overview of the currently existing transaction steps.

Working With Features Feature Creation Features are the building blocks of a model in GenerativeComponents. At the time of creation, every geometric feature has to be defined with respect to a reference of a compatible type. When creating a feature, GenerativeComponents lists which references are required as inputs for a given feature, depending on its update method. These are called parameters. Once all necessary parameters are filled in and the feature has been created, the Symbolic Diagram visualizes the associations between the newly created features and the reference features that define its dependencies.

Feature Creation Tools The easiest way to create a basic feature is to use the three feature creation tools for creating points, planes, and coordinate systems. These tools only allow for a few of the most often used creation types such as by Cartesian coordinates, on a plane, or by parameter along a curve. Only update methods that use geometrically accessible features in the Geometry window are available through the tools.

To create a point using the shortcut, click the Create Point tool and then pick a location in the Geometry window. By default, the point is placed on the baseCS.XY plane, which is similar to creating a point using the OnPlane update method. The original location of the point does not have to be absolute as its exact location can be edited with extreme precision later by using the Move or Edit Feature tool.

To place a new point on a line, curve, or surface, click the Create Point tool, click in the Geometry window, and press the Ctrl key to place it.

The method for creating a new point described above also works for planes and coordinate systems because all three feature types implement the IPoint interface. For these types of geometry, use the Create Plane or Create Coordinate System tools. Then, in the Geometry window place them either by Cartesian coordinates, or on a line, curve, or surface.

Feature Library To create a feature such as a B‐spline curve, line, or solid, access the feature library by clicking the Create Feature tool.

Update Methods Each feature type within the feature library has a plus sign (+) next to it. Clicking this symbol expands each feature type to reveal all available update methods associated with it. Update methods define how a feature is created and its dependencies within the model. This requires a certain degree of structuring the design beforehand but the update method used to create the feature can be changed through editing the feature.

Every feature has a number of different update methods, and each update method has a set of different inputs that distinguish it from the other update methods.

Feature

Input

Properties Each update contains a list of properties that defined in order feature. Just as a expanded to update methods, plus sign (+) input methods specific update

method input must be to create the feature type is reveal its clicking the expands the required by a method.

Data Types Every input property within an update method requires that a specific type of data be input. Data types are the various types of inputs that are allowed to fulfill the input property requirements. The most common data types for an input property in GenerativeComponents are strings, numbers (integers and doubles), Boolean values, a function, or a feature itself.

A string is a sequence of text characters contained by quotes ("").

Numeric types are an Integer (int) or Double. Integers are whole numbers like 1, 3, 7, while Doubles contain decimal positions such as 1.345 , or 5.5 or 5.0. Assigning a Double value to a variable of type Int rounds the value to the closest whole number.

In addition to numeric values, input properties can accept a feature value or property. For example, Line.Length is equivalent to an input type Double.

The logic type is a Boolean, which can either be true or false.

A function is an expression that takes a series of arguments and processes them before returning a value. For a more in‐depth discussion of functions, refer to the Functions section below.

In many cases, a feature is also a valid input property. For example, when creating a Line.ByPoints, the two properties required are a “StartPoint: IPoint” and an “EndPoint: IPoint”. Here, any feature that implements the IPoint interface is a valid input (Point, Plane, or CoordinateSystem).

For a more in‐depth discussion of data types, refer to the GenerativeComponents script language reference.

Interfaces In GenerativeComponents, many update methods require a specific property from a feature as an input parameter. Just like the different data types, there are different interfaces that associate sets of features which are not related in a strict hierarchy but have common properties or behaviors. In GenerativeComponents and most other object‐oriented programming languages, this concept is known as an “Interface”.

Interfaces are important because they refer to families of objects but are themselves not features. An interface is similar to a "promise" of a feature to provide certain information (in terms of querying certain named properties of a defined type) or to exhibit certain behaviors.

Typically, data and feature types are arranged in a strict hierarchy, while interfaces can cross this hierarchy and express important shared geometric properties and behavior.

For example, every point that implements the IPoint interface must report its X, Y, Z coordinate values.

Therefore, in the diagram below we can see that a Point feature implements the IPoint interface, as does a plane and a coordinate system.

Another example is that both the Plane type and the Line type implement the IDirection interface, even though these types are only peripherally related in the feature type hierarchy. This means that when a “Direction” is required (in a geometric operation such as projection, etc.) it is equally valid to provide a line or a plane.

In the diagram below, if a feature implements an interface (or lies within the dotted lines of a particular interface) it can be used as such. For instance, a method asking for an IDirection can accept a plane, direction, or line because these features implement the IDirection interface.

Single Input Parameters Some input properties require only a single input to define their value. For example, when creating a Line.ByStartPointDirectionLength, each parameter accepts as few as one input, such as “point01” for the StartPoint, “direction01” for the Direction, and 3.65 for the Length.

Clicking in the input field allows you to fill in the input values.

In this example StartPoint is the name of the Input property. IPoint stands for the type of input that is possible for this particular input. In this case, anything that implements the IPoint interface can be used as an input for the StartPoint. A point, a coordinate system, and a plane implement the IPoint interface and can be used interchangeably (as does a line's start or end point – line01.EndPoint). The text “(repl.)” signifies that either a single input value (like a single point) or a list of features can be used. Similarly, Direction implements the IDirectionOrPoint interface. Therefore any direction, line, curve, point, plane, or coordinate system is an acceptable input.

Exchanging Data with Microsoft Office and Databases In order to extend its functionality beyond importing and exporting geometry files, GenerativeComponents is also capable of interfacing with Microsoft Office applications. Using built‐in features, it is possible to read and write data from Excel spreadsheets, Access databases files, text (*txt) files, and even external databases. Two feature types listed in the features library are present when first opening GenerativeComponents: DataExporter and DataImporter. These features interface with Access databases and text files. There is one additional feature type that interfaces with Excel, though it is not initially present when GenerativeComponents is first installed: ExcelRange.

Loading the Bentley.GenerativeComponents.Office.dll In order to use the ExcelRange features you need to import the Bentley.GenerativeComponents.Office.dll file in the Manage Loaded Assemblies dialog. (On the GenerativeComponents menu bar, click Tools > Manage Loaded Assemblies.)

Click the Select Pre‐compiled Assembly File (*.dll) button. You can select the Bentley.GenerativeComponents.Office.dll file in the Assemblies folder located in the GenerativeComponents installation directory. In the case of a default install the directory is C:\Program Files\Bentley\GenerativeComponents\Assemblies.

Select the Bentley.GenerativeComponents.Office.dll file to add Microsoft Office interoperability to GenerativeComponents.

Exchanging Data with Excel Spreadsheets are a useful way to store data. Consisting of a raw table of cells, the data in the spreadsheet can be organized in a table or in less formal ways.

Moreover, you can define expressions to define particular cells from the value of other cells. Using the ExcelRange feature in GenerativeComponents you can either read or write data to a spreadsheet. As long as you are not referencing the same range, you can even read and write values to the same sheet. The advantage of referencing an Excel spreadsheet versus a database is that irregular (or less formal) data organizations can be made, with both input and outputs defined on the same spreadsheet, with a variety of formulas linking cells, all combined with your desired spreadsheet format.

Although it is possible for a GenerativeComponents model to read data from the same spreadsheet that it is writing to, it is not possible to create a complete loop between a GenerativeComponents feature and an Excel cell. (For example, it is not possible for GenerativeComponents to write data to the same cell from which it is reading data. This type of “circular reference” is not supported.

ExcelRange.ReadValue In the following example, we use a spreadsheet filled with point coordinate values to create a list of points. Start by making a simple spreadsheet where each column represents an X, Y, and Z value. Every row then represents a single point’s X,Y,Z value.

In the spreadsheet below, the first point has the coordinates (1,5,6), the second (2,5,1), and so on. Save the spreadsheet so that it can be easily accessible later.

The next step in GenerativeComponents is to establish a link with the spreadsheet you just created. Using the ExcelRange.ReadValue feature, use the f(x) button to navigate to your spreadsheet, and then specify the spreadsheet to query in the SheetName property. For the RangeAddress parameter, define a range from the first cell value to the last, beginning in the upper left‐hand corner of your spreadsheet to the lowest cell on the right.

Once the ExcelRange feature has been created, the values contained within it can be used to create a list of points. The easiest feature to achieve this is with the Point.ByCoordinateList feature.

After specifying a host coordinate system, the contents of the ExcelRange must be extracted for the XYZTranslation input property using the dot operator (.). In order to access this information, input the name of the ExcelRange into the XYZTranslation field. In this case the name is "excelRange01".

Press the period key on your keyboard (.) to open the list of properties associated with the ExcelRange. Scroll down to the Value property or press V on your keyboard to jump directly to it. (If it is not there, just type "Value".) The input should look like the code below: XYZTranslation = excelRange01.Value In the image below, a B‐spline curve with an order of three has been drawn through the points.

At any point in the future, the spreadsheet can be edited and GenerativeComponents will read the new values before updating the Geometry window. After the spreadsheet is updated and saved, simply click the Update All Graphs tool in the GenerativeComponents toolbar or replay the transaction containing the ExcelRange feature.

ExcelRange.WriteValue Writing information to an Excel spreadsheet is similar to reading data. First save a spreadsheet that you can access from GenerativeComponents. In this example we use the same spreadsheet from which we read data earlier.

In the ExcelRange.WriteValue input properties, input the file path for the spreadsheet in the WorkbookFileName field and specify a sheet in the SheetName property.

Assign a cell or range of cells as a string in the RangeAddress field, in this case "A6."

The value to be written to an Excel spreadsheet can vary widely; nearly all data types are valid, including combinations of different data types. In this example, we simply export the length of the curve drawn through the points that were based on the spreadsheet's coordinate values. However, rather than simply report the length of the curve, we would also like to notate what the value is referring to. The first value to export is a string, followed by the length property of the feature "bsplineCurve01." In order for GenerativeComponents to understand that it needs to export multiple values, each value must be concatenated, or separated by the plus (+) symbol. This is the C# and GCScript convention for joining two strings, though it will work with more than just string values.

For more information on GCScript, refer to the GCScript programming language section.

The string portion of the input property is "Curve Length = ". Then we use the plus (+) symbol to indicate more values will be exported. The second value is the length of the B‐spline curve. This value is accessed by using the dot operator (.): bsplineCurve01.Length. At this point we can click OK but the output will be accurate to 13 decimal places. To shorten the decimal, we use the Round() function, specifying that GenerativeComponents should round the value to a less precise number. The input should look like the following: Value = "Curve Length = " + Round(bsplineCurve01.Length, 3)

Clicking OK exports the value to Excel. The current length of the curve is 17.153.

The new link to Excel is dynamic and will change every time the associated value changes. For instance, the ExcelRange.WriteValue could be linked to the length of a curve defined by points made in GenerativeComponents. In this case, every time a point is moved and the length of the curve changes dynamically, so will the value in Excel.

Exchanging Data with Databases and Text Files In addition to exchanging data with Excel, GenerativeComponents is also capable of exchanging data with external databases, database files, and text files. This extends the interoperability of GenerativeComponents far beyond a traditional geometric modeling program.

Comma Separated ACSII Text Files Comma separated ACSII files containing point coordinates are the simplest and most compact formats for coordinate data, and provides a universal medium for the exchange of data with a number of applications, survey instruments and other devices, both input and output. Using the Point.ByCoordinatesFromExternalFile feature, GenerativeComponents uses this data to build a point feature consisting of a list of points, where the sequence of lines in the ASCII file corresponds to the index of each point in the resultant list.

Data Importer / Exporter Two features exist that allow GenerativeComponents to interface with external databases, as well as database and text files: DataImporter and DataExporter. Each of these two features share the same update methods, allowing you to connect to an external database to read and write data, access a database file stored on an accessible drive, or access a similarly available text file. When connecting to an external database, GenerativeComponents is compatible with four database connection APIs: Open Database Connectivity (ODBC), OLE DB (Object Linking and Embedding, Database), Oracle, and SQL (Structured Query Language).

GenerativeComponents is also compatible with four types of database files: Microsoft Access, Microsoft SQL Server Express, Text, and Microsoft Visual Fox Pro. For a basic example of importing and exporting databases, refer to the Data Importer / Exporter section of the feature library.

Empowered by computational methods, designers can direct their creativity to deliver inspired sustainable buildings that are freer in form and use innovative materials and assemblies. GenerativeComponents facilitates this by allowing the quick exploration of a broad range of “what‐if” alternatives for even the most complex buildings.

This unique generative design software captures and exploits the critical relationships between design intent and geometry. Designs can be refined by either dynamically modeling and directly manipulating geometry, by applying rules and capturing relationships among building elements, or by defining complex building forms and systems through concisely expressed algorithms.

To inform decisions, GenerativeComponents is integrated with building information modeling, analysis, and simulation software, providing feedback on building materials, assemblies, systems performance, and environmental conditions. This integration also ensures that intent becomes reality by enabling designs toaccurately and efficiently flow through to detailed production and fabrication.