revit 可视化编程插件Dynamo使用手册

Dynamo Language Manual

Contents

1. Language Basics

2. Geometry Basics

3. Geometric Primitives

4. Vector Math

5. Range Expressions

6. Collections

7. Functions

8. Math

9. Curves: Interpreted and Control Points

10. Translation, Rotation, and Other Transformations

11. Conditionals and Boolean Logic

12. Looping

13. Replication Guides

14. Collection Rank and Jagged Collections

15. Surfaces: Interpreted, Control Points, Loft, Revolve

16. Geometric Parameterization

17. Intersection and Trim

18. Geometric Booleans

A-1. Appendix 1: Python Point Generators

Introduction

Programming languages are created to express ideas, usually

involving logic and calculation. In addition to these objectives, the

Dynamo textual language (formerly DesignScript) has been

created to express design intentions. It is generally recognized

that computational designing is exploratory, and Dynamo tries to

support this: we hope you find the language flexible and fast

enough to take a design from concept, through design iterations,

to your final form.

This manual is structured to give a user with no knowledge of

either programming or architectural geometry full exposure to a

variety of topics in these two intersecting disciplines. Individuals

with more experienced backgrounds should jump to the individual

sections which are relevant to their interests and problem

domain. Each section is self-contained, and doesn’t require any

knowledge besides the information presented in prior sections.

Text blocks inset in the Consolas font should be pasted into a

Code Block node. The output of the Code Block should be

connected into a Watch node to see the intended result. Images

are included in the left margin illustrating the correct output of

your program.

This document discusses the Dynamo textual programming language, used inside of the Dynamo editor (sometimes referred to as “Dynamo Sandbox”). To create a new Dynamo script, open the Dynamo editor, and select the “New” button in the “FILES” group:

This will open a blank Dynamo graph. To write a Dynamo text

script, double click anywhere in the canvas. This will bring up a

“Code Block” node. In order to easily see the results of our

scripts, attach a “Watch” node to the output of your Code Block

node, as shown here:

Every script is a series of written commands. Some of these

commands create geometry; others solve mathematical

problems, write text files, or generate text strings. A simple, one

line program which generates the quote “Less is more.” looks like

this:

The Watch node on the left shows the output of the script.

"Less is more.";

1: Language Basics

The command generates a new String object. Strings in Dynamo

are designated by two quotation marks ("), and the enclosed

characters, including spaces, are passed out of the node. Code

Block nodes are not limited to generating Strings. A Code Block

node to generate the number 5420 looks like this: Every command in Dynamo is terminated by a semicolon. If you

do not include one, the Editor will add one for you. Also note that

the number and combination of spaces, tabs, and carriage

returns, called white space, between the elements of a command

do not matter. This program produces the exact same output as

the first program:

Naturally, the use of white space should be used to help improve

the readability of your code, both for yourself and future readers.

Comments are another tool to help improve the readability of

your code. In Dynamo, a single line of code is “

commented ” with

two forward slashes, //. This makes the node ignore everything

written after the slashes, up to a carriage return (the end of the

line). Comments longer than one line begin with a forward slash

asterisk, /*, and end with an asterisk forward slash, */.

5420;

"Less Is More."

;

So far the Code Block arguments have been ‘literal’ values, either a text string or a number. However it is often more useful for function arguments to be stored in data containers called variables, which both make code more readable, and eliminate redundant commands in your code. The names of variables are up to individual programmers to decide, though each variable name must be unique, start with a lower or uppercase letter, and contain only letters, numbers, or underscores, _. Spaces are not allowed in variable names. Variable names should, though are not required, to describe the data they contain. For instance, a variable to keep track of the rotation of an object could be called rotation. To describe data with multiple words, programmers typically use two common conventions: separate the words by capital letters, called camelCase (the successive capital letters mimic the humps of a camel), or to separate individual words with underscores. For instance, a variable to describe the rotation of a

small disk might be named

smallDiskRotation or

small_disk_rotation, depending on the programmer’s stylistic preference. To create a variable, write its name to the left of an equal sign, followed by the value you want to assign to it. For instance:

Besides making readily apparent what the role of the text string is, variables can help reduce the amount of code that needs updating if data changes in the future. For instance the text of the following quote only needs to be changed in one place, despite its appearance three times in the program.

// This is a single line comment

/* This is a multiple line comment,

which continues for multiple

lines. */

// All of these comments have no effect on

// the execution of the program

// This line prints a quote by Mies van der Rohe

"Less Is More";

quote = "Less is more.";

Here we are joining a quote by Mies van der Rohe three times,

with spaces between each phrase. Notice the use of the +

operator to ‘concatenate’ the strings and variables together to

form one continuous output.

// My favorite architecture quote

quote = "Less is more.";

quote + " " + quote + " " + quote;

// My NEW favorite architecture quote

quote =

"Less is a bore.";

quote + " " + quote + " " + quote;

The simplest geometrical object in the Dynamo standard

geometry library is a point. All geometry is created using special

functions called constructors, which each return a new instance

of that particular geometry type. In Dynamo, constructors begin

with th e name of the object’s type, in this case Point , followed by

the method of construction. To create a three dimensional point

specified by x, y, and z Cartesian coordinates, use the

ByCoordinates constructor: Constructors in Dynamo are typically design ated with the “By ”

prefix, and invoking these functions returns a newly created

object of that type. This newly created object is stored in the

variable named on the left side of the equal sign, and any use of

that same original Point.

Most objects have many different constructors, and we can use

the BySphericalCoordinates constructor to create a point lying

on a sphere, specified by the sphere’s radius, a first rotation

angle, and a second rotation angle (specified in degrees):

// create a point with the following x, y, and z

// coordinates: x = 10; y = 2.5; z = -6;

p = Point.ByCoordinates(x, y, z);

// create a point on a sphere with the following radius, // theta, and phi rotation angles (specified in degrees)

radius = 5;

theta = 75.5;

phi = 120.3;

cs = CoordinateSystem.Identity();

p = Point.BySphericalCoordinates(cs, radius, theta,

phi);

2: Geometry Basics

Points can be used to construct higher dimensional geometry

such as lines. We can use the ByStartPointEndPoint

constructor to create a Line object between two points: Similarly, lines can be used to create higher dimensional surface

geometry, for instance using the Loft constructor, which takes a

series of lines or curves and interpolates a surface between

them.

Surfaces too can be used to create higher dimensional solid

geometry, for instance by thickening the surface by a specified

distance. Many objects have functions attached to them, called

methods, allowing the programmer to perform commands on that

particular object. Methods common to all pieces of geometry

include Translate and Rotate , which respectively translate

(move) and rotate the geometry by a specified amount. Surfaces

have a Thicken method, which take a single input, a number

specifying the new thickness of the surface.

// create two points: p1 = Point.ByCoordinates(3, 10, 2);

p2 = Point.ByCoordinates(-15, 7, 0.5);

// construct a line between p1 and p2

l = Line.ByStartPointEndPoint(p1, p2);

// create points:

p1 = Point.ByCoordinates(3, 10, 2);

p2 = Point.ByCoordinates(-15, 7, 0.5);

p3 = Point.ByCoordinates(5, -3, 5);

p4 = Point.ByCoordinates(-5, -6, 2);

p5 = Point.ByCoordinates(9, -10, -2);

p6 = Point.ByCoordinates(-11, -12, -4);

// create lines:

l1 = Line.ByStartPointEndPoint(p1, p2);

l2 = Line.ByStartPointEndPoint(p3, p4);

l3 = Line.ByStartPointEndPoint(p5, p6);

// loft between cross section lines:

surf = Surface.ByLoft({l1, l2, l3});

Intersection commands can extract lower dimensional

geometry from higher dimensional objects. This extracted lower

dimensional geometry can form the basis for higher dimensional

geometry, in a cyclic process of geometrical creation, extraction,

and recreation. In this example, we use the generated Solid to

create a Surface, and use the Surface to create a Curve.

p1 = Point.ByCoordinates(3, 10, 2);

p2 = Point.ByCoordinates(-15, 7, 0.5);

p3 = Point.ByCoordinates(5, -3, 5);

p4 = Point.ByCoordinates(-5, -6, 2);

l1 = Line.ByStartPointEndPoint(p1, p2);

l2 = Line.ByStartPointEndPoint(p3, p4);

surf = Surface.ByLoft({l1, l2});

// true indicates to thicken both sides of the Surface:

solid = surf.Thicken(4.75, true);

p1 = Point.ByCoordinates(3, 10, 2);

p2 = Point.ByCoordinates(-15, 7, 0.5);

p3 = Point.ByCoordinates(5, -3, 5);

p4 = Point.ByCoordinates(-5, -6, 2);

l1 = Line.ByStartPointEndPoint(p1, p2);

l2 = Line.ByStartPointEndPoint(p3, p4);

surf = Surface.ByLoft({l1, l2});

solid = surf.Thicken(4.75, true);

p = Plane.ByOriginNormal(Point.ByCoordinates(2, 0, 0),

Vector.ByCoordinates(1, 1, 1));

int_surf = solid.Intersect(p);

int_line = int_surf.Intersect(Plane.ByOriginNormal(

Point.ByCoordinates(0, 0, 0),

Vector.ByCoordinates(1, 0, 0)));

While Dynamo is capable of creating a variety of complex

geometric forms, simple geometric primitives form the backbone

of any computational design: either directly expressed in the final

designed form, or used as scaffolding off of which more complex

geometry is generated.

While not strictly a piece of geometry, the CoordinateSystem is

an important tool for constructing geometry. A CoordinateSystem

object keeps track of both position and geometric transformations

such as rotation, sheer, and scaling.

Creating a CoordinateSystem centered at a point with x = 0, y =

0, z = 0, with no rotations, scaling, or sheering transformations,

simply requires calling the Identity constructor: CoordinateSystems with geometric transformations are beyond

the scope of this chapter, though another constructor allows you

to create a coordinate system at a specific point,

CoordinateSystem.ByOriginVectors :

The simplest geometric primitive is a Point, representing a zero-

dimensional location in three-dimensional space. As mentioned

earlier there are several different ways to create a point in a

particular coordinate system: Point.ByCoordinates creates a

// create a CoordinateSystem at x = 0, y = 0, z = 0,

// no rotations, scaling, or sheering transformations

cs = CoordinateSystem.Identity();

// create a CoordinateSystem at a specific location, // no rotations, scaling, or sheering transformations x_pos = 3.6;

y_pos = 9.4; z_pos = 13.0;

origin = Point.ByCoordinates(x_pos, y_pos, z_pos);

identity = CoordinateSystem.Identity();

cs = CoordinateSystem.ByOriginVectors(origin,

identity.XAxis, identity.YAxis, identity.ZAxis);

3: Geometric Primitives

point with specified x, y, and z coordinates;

Point.ByCartesianCoordinates creates a point with a specified

x, y, and z coordinates in a specific coordinate system ;

Point.ByCylindricalCoordinates creates a point lying on a

cylinder with radius, rotation angle, and height; and

Point.BySphericalCoordinates creates a point lying on a

sphere with radius and two rotation angle.

This example shows points created at various coordinate

systems:

The next higher dimensional Dynamo primitive is a line segment,

representing an infinite number of points between two end points.

Lines can be created by explicitly stating the two boundary points

with the constructor Line.ByStartPointEndPoint , or by

specifying a start point, direction, and length in that direction,

Line.ByStartPointDirectionLength .

// create a point with x, y, and z coordinates

x_pos = 1;

y_pos = 2;

z_pos = 3;

pCoord = Point.ByCoordinates(x_pos, y_pos, z_pos);

// create a point in a specific coordinate system

cs = CoordinateSystem.Identity();

pCoordSystem = Point.ByCartesianCoordinates(cs, x_pos,

y_pos, z_pos);

// create a point on a cylinder with the following

// radius and height

radius = 5;

height = 15;

theta = 75.5;

pCyl = Point.ByCylindricalCoordinates(cs, radius, theta, height);

// create a point on a sphere with radius and two angles

phi = 120.3;

pSphere = Point.BySphericalCoordinates(cs, radius,

theta, phi);

Dynamo has objects representing the most basic types of

geometric primitives in three dimensions: Cuboids, created with

Cuboid.ByLengths ; Cones, created with Cone.ByPointsRadius

and Cone.ByPointsRadii ; Cylinders, created with

Cylinder.ByRadiusHeight ; and Spheres, created with

Sphere.ByCenterPointRadius .

p1 = Point.ByCoordinates(-2, -5, -10);

p2 = Point.ByCoordinates(6, 8, 10);

// a line segment between two points

l2pts = Line.ByStartPointEndPoint(p1, p2);

// a line segment at p1 in direction 1, 1, 1 with

// length 10

lDir = Line.ByStartPointDirectionLength(p1,

Vector.ByCoordinates(1, 1, 1), 10);

// create a cuboid with specified lengths

cs = CoordinateSystem.Identity();

cub = Cuboid.ByLengths(cs, 5, 15, 2);

// create several cones

p1 = Point.ByCoordinates(0, 0, 10); p2 = Point.ByCoordinates(0, 0, 20); p3 = Point.ByCoordinates(0, 0, 30);

cone1 = Cone.ByPointsRadii(p1, p2, 10, 6);

cone2 = Cone.ByPointsRadii(p2, p3, 6, 0);

// make a cylinder

cylCS = cs.Translate(10, 0, 0);

cyl = Cylinder.ByRadiusHeight(cylCS, 3, 10);

// make a sphere

centerP = Point.ByCoordinates(-10, -10, 0);

sph = Sphere.ByCenterPointRadius(centerP, 5);

Objects in computational designs are rarely created explicitly in

their final position and form, and are most often translated,

rotated, and otherwise positioned based off of existing geometry.

Vector math serves as a kind-of geometric scaffolding to give

direction and orientation to geometry, as well as to conceptualize

movements through 3D space without visual representation.

At its most basic, a vector represents a position in 3D space, and

is often times thought of as the endpoint of an arrow from the

position (0, 0, 0) to that position. Vectors can be created with the

ByCoordinates constructor, taking the x, y, and z position of the

newly created Vector object. Note that Vector objects are not

geometric objects, and don’t appear in the Dynamo window.

However, information about a newly created or modified vector

can be printed in the console window: A set of mathematical operations are defined on Vector objects,

allowing you to add, subtract, multiply, and otherwise move

objects in 3D space as you would move real numbers in 1D

space on a number line.

Vector addition is defined as the sum of the components of two

vectors, and can be thought of as the resulting vector if the two

component vector arrows are placed “tip to tail.” Vector addition

is performed with the Add method, and is represented by the

diagram on the left.

// construct a Vector object v = Vector.ByCoordinates(1, 2, 3);

s = v.X + " " + v.Y + " " + v.Z;

a = Vector.ByCoordinates(5, 5, 0);

b = Vector.ByCoordinates(4, 1, 0);

// c has value x = 9, y = 6, z = 0

c = a.Add(b);

4: Vector Math

Similarly, two Vector objects can be subtracted from each other

with the Subtract method. Vector subtraction can be thought of

as the direction from first vector to the second vector. Vector multiplication can be thought of as moving the endpoint of

a vector in its own direction by a given scale factor.

Often it’s desired when scaling a vector to have the resulting

vector’s length exactly equal to the scaled amount. This is easily

achieved by first normalizing a vector, in other words setting the

vector’s length exactly equal to one.

c still points in the same direction as a (1, 2, 3), though now it has

length exactly equal to 5.

a = Vector.ByCoordinates(5, 5, 0);

b = Vector.ByCoordinates(4, 1, 0);

// c has value x = 1, y = 4, z = 0 c = a.Subtract(b);

a = Vector.ByCoordinates(4, 4, 0);

// c has value x = 20, y = 20, z = 0

c = a.Scale(5);

a = Vector.ByCoordinates(1, 2, 3);

a_len = a.Length;

// set the a's length equal to 1.0

b = a.Normalized();

c = b.Scale(5);

// len is equal to 5

len = c.Length;

Two additional methods exist in vector math which don’t have

clear parallels with 1D math, the cross product and dot product.

The cross product is a means of generating a Vector which is

orthogonal (at 90 degrees to) to two existing Vectors. For

example, the cross product of the x and y axes is the z axis,

though the two input Vectors don’t need to be orthogonal to each

other. A cross product vector is calculated with the Cross

method. An additional, though somewhat more advanced function of

vector math is the dot product. The dot product between two

vectors is a real number (not a Vector object) that relates to, but

is not exactly , the angle between two vectors. One useful

properties of the dot product is that the dot product between two

vectors will be 0 if and only if they are perpendicular. The dot

product is calculated with the Dot method.

a = Vector.ByCoordinates(1, 0, 1);

b = Vector.ByCoordinates(0, 1, 1);

// c has value x = -1, y = -1, z = 1

c = a.Cross(b);

a = Vector.ByCoordinates(1, 2, 1);

b = Vector.ByCoordinates(5, -8, 4);

// d has value -7

d = a.Dot(b);

Almost every design involves repetitive elements, and explicitly

typing out the names and constructors of every Point, Line, and

other primitives in a script would be prohibitively time consuming.

Range expressions give a Dynamo programmer the means to

express sets of values as parameters on either side of two dots

(..), generating intermediate numbers between these two

extremes.

For instance, while we have seen variables containing a single

number, it is possible with range expressions to have variables

which contain a set of numbers. The simplest range expression

fills in the whole number increments between the range start and

end. In previous examples, if a single number is passed in as the

argument of a function, it would produce a single result. Similarly,

if a range of values is passed in as the argument of a function, a

range of values is returned.

For instance, if we pass a range of values into the Line

constructor, Dynamo returns a range of lines.

By default range expressions fill in the range between numbers

incrementing by whole digit numbers, which can be useful for a

quick topological sketch, but are less appropriate for actual

designs. By adding a second ellipsis (..) to the range expression, you can specify the amount the range expression

increments between values. Here we want all the numbers

between 0 and 1, incrementing by 0.1:

a = 1..6;

x_pos = 1..6;

y_pos = 5;

z_pos = 1;

lines = Line.ByStartPointEndPoint(Point.ByCoordinates(0,

0, 0), Point.ByCoordinates(x_pos, y_pos, z_pos));

5: Range Expressions

One problem that can arise when specifying the increment between range expression boundaries is that the numbers

generated will not always fall on the final range value. For

instance, if we create a range expression between 0 and 7,

incrementing by 0.75, the following values are generated:

If a design requires a generated range expression to end

precisely on the maximum range expression value, Dynamo can

approximate an increment, coming as close as possible while still

maintaining an equal distribution of numbers between the range

boundaries. This is done with the approximate sign (~) before the

third parameter:

However, if you want to Dynamo to interpolate between ranges

with a discrete number of elements, the # operator allows you to

specify this:

a = 0..1..0.1;

a = 0..7..0.75;

// DesignScript will increment by 0.777 not 0.75

a = 0..7..~0.75;

// Interpolate between 0 and 7 such that

// “a” will contain 9 element s

a = 0..7..#9;

Collections are special types of variables which hold sets of

values. For instance, a collection might contain the values 1 to

10, {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, assorted geometry

from the result of an Intersection operation, {Surface, Point,

Line, Point}, or even a set of collections themselves, { {1, 2,

3}, {4, 5}, 6}.

One of the easier ways to generate a collection is with range

expressions (see: Range Expressions ). Range expressions by

default generate collections of numbers, though if these

collections are passed into functions or constructors, collections

of objects are returned. When range expressions aren’t appropriate, collections can be

created empty and manually filled with values. The square

bracket operator ([]) is used to access members inside of a

collection. The square brackets are written after the variable’s

name, with the number of the individual collection member

contained inside. This numb er is called the collection member’s

index. For historical reasons, indexing starts at 0, meaning the

first element of a collection is accessed with: collection[0],

and is often called the “zeroth” number. Subsequent members

are accessed by increasing the index by one, for example:

The individual members of a collection can be modified using the same index operator after the collection has been created:

// use a range expression to generate a collection of // numbers nums = 0..10..0.75;

// use the collection of numbers to generate a

// collection of Points

points = Point.ByCoordinates(nums, 0, 0);

// a collection of numbers

nums = 0..10..0.75;

// create a single point with the 6th element of the

// collection

points = Point.ByCoordinates(nums[5], 0, 0);

6: Collections

In fact, an entire collection can be created by explicitly setting every member of the collection individually. Explicit collections

are created with the curly brace operator ({}) wrapping the

collection’s starting values, or left empty to create an empty

collection:

Collections can also be used as the indexes to generate new sub

collections from a collection. For instance, a collection containing

the numbers {1, 3, 5, 7}, when used as the index of a

collection, would extract the 2nd , 4th , 6th , and 8th elements from a

collection (remember that indices start at 0):

Dynamo contains utility functions to help manage collections. The

Count

function, as the name implies, counts a collection and

returns the number of elements it contains.

// generate a collection of numbers

a = 0..6;

// change several of the elements of a collection

a[2] = 100;

a[5] = 200;

// create a collection explicitly

a = { 45, 67, 22 };

// create an empty collection

b = {};

// change several of the elements of a collection

b[0] = 45;

b[1] = 67;

b[2] = 22;

a = 5..20;

indices = {1, 3, 5, 7};

// create a collection via a collection of indices

b = a[indices];

Revit软件组合使用

Revit软件组合使用，让你的工作事半功倍 每当谈到关于BIM软件的话题，大部分人会首先想到Revit。Revit是目前BIM软件中较为知名的一款工具软件，它的教学信息丰富，学习时间短且容易上手，受到大多数Bimer的热捧。但BIM应用涉及的范围很广，Revit在某些方面也存在短板，常常需要和其他软件组合使用，才能满足相关需求。常见的Revit与其他软件的组合有哪些？下面给大家分享一下常见软件组合的主要功能、应用思路和模型转换方法。一、Revit 每当谈到关于BIM软件的话题，大部分人会首先想到R evit。Revit是目前BIM 软件中较为知名的一款工具软件，它的教学信息丰富，学习时间短且容易上手，受到大多数Bimer的热捧。但BIM应用涉及的范围很广，Revit在某些方面也存在短板，常常需要和其他软件组合使用，才能满足相关需求。常见的R evit与其他软件的组合有哪些？下面给大家分享一下常见软件组合的主要功能、应用思路和模型转换方法。 一、Revit与曲面建模软件Rhino的组合 图1 Rhino模型界面

图2 Revit模型界面 二、Revit与钢结构建模软件Tekla的组合 功能介绍：Revit具有强大的建模功能，但在创建异形曲面方面能力较弱，往往难以满足实际需要。Rhino在创建异形曲面模型方面能力卓越，可以创建、编辑、分析和转换NURBS曲线、曲面和实体，并且在复杂程度、角度和尺寸方面没有任何限制。在需要创建异形建筑时，可以把这两款软件结合起来使用，提高工作效率。 应用思路:在工程项目中，经常会遇到需要创建复杂的屋顶、异形的建筑外立面或场地，可以利用Rhino在异形曲面方面建模的优势，快速创建模型。然后在Rhino里导出模型文件，再载入到Revit中进行深化，以提高模型质量及建模效率。 模型转换方法：Rhino导出.sat格式文件→Revit新建概念体量→插入.sat格式文件→载入项目→深化模型（也可以利用插件以.ifc格式文件为媒介转换，可以达到Rhino与Revit的互通，但有一定几率导入失败。

Revit2015基本操作说明

Revit2015基本操作说明

目录 一、Revit2015软件界面说明 (3) 二、Revit2015软件简单操作 (7) 1、打开文件 (7) 2、调整和查看视图 (8) 3、制作和查看剖面 (11) 4、查看构件尺寸 (12) 5、链接和导入CAD平面 (15) 6、链接Revit模型 (15) 7、查看图纸 (17) 8、查看标高和高程坐标 (17) 9、导出文件 (19) 三、Revit2015软件常用快捷键 (21)

一、 Revit2015软件界面说明 Revit2015界面主要包括应用程序菜单、快速访问工具栏、信息中心、功能区、选项栏、项目浏览器、绘图区域、视图控制栏、状态栏等几个区域。 1、 应用程序菜单 应用程序菜单主要实现多个文件同时操作，还可以使用更高级的操作如“导出”和“发布”等。 （1） 快速访问工具栏 快速访问工具栏主要用于显示常用工具，在操作过程中可以更快

的找到要使用的命令，快速访问工具栏上的命令进行自定义，添加一些常用的命令。 快速访问工具栏空白处，选择自定义快速访问工具栏进行编辑。 2、 功能区 快速访问工具栏

创建或打开文件时自动显示，并提供创建文件时所需要的全部工具 通过拖拽等方式，自定义功能区排列顺序，也可以最小化功能区，从而最大程度的使用绘图区域。 3、选项栏 选项栏位于功能区下方，其内容根据当前命令或所选图元变化。 4、属性 将现有图元改成其他类型。

5、项目浏览器 项目浏览器用于显示所有视图、明细表、图纸、族、组、链接的 revit模型等其他逻辑层次，展开和折叠各分支时显示下一层项目。 6、绘图区域

Revit入门教程(一看就会)要点

Revit入门级小教程（原创~） 写在前面： REVIT作为一款专门面向建筑的软件，它的功能是非常强大的，它可以兼任辅助建筑设计和建筑表现两方面工作，以下所谈到的建模过程指的是建筑表现方面的工作，用REVIT辅助建筑设计需要设计者对REVIT建模有着非常熟练的掌握，相比于辅助建筑设计，对于初学者来说用REVIT来做建筑表现更加容易上手一些。因此以下所谈到的REVIT建模主要是针对建筑表现方面。 建模观念上的改变： REVIT作为一款BIM软件，它的建模跟我们平时常用到的建模软件，如SKETCH UP，RHINO 等，还是有着不小的差距的，要接受这款软件，在建模观念上就需要有一些改变。 如果把常用的SKETCH UP、RHINO比作手工模型的话，REVIT便可以比作实际建造，SKETCH UP、RHINO等软件的建模是通过形体的组成来完成，而REVIT的建模是通过组合不同的建筑元素来完成，如梁、柱、门、窗等等。既然是模拟实际建造，便有着实际建造的一些特点，如掌握建筑各部分精确的尺寸，了解建筑各部分材料的运用，构造做法等等，综合来说，用REVIT建模，必须对你的建筑方案有深入准确的了解，才可以建出一个完善的REVIT模型。这个观念对于一个刚刚接触REVIT的同学来说是很重要的，对自己的建筑方案了解的不够准确细致深入的话，建模的时候会碰到很多困难，让自己不得不停下手中的建模工作，来确定某一部分的尺寸、材料或构造等。REVIT模型的细致程度最终取决于设计者所做的方案的深度和对方案的了解程度。 两个重要的专有名词： 我从官方解释和我个人的理解两个方面来说一下对于REVIT中两个比较重要的专有名词的意思 样板文件： 官方解释：项目样板提供项目的初始状态。Revit Architecture 提供几个样板，您也可以创建自己的样板。基于样板的任意新项目均继承来自样板的所有族、设置（如单位、填充样式、线样式、线宽和视图比例）以及几何图形。 个人的理解：如果把一个REVIT项目比作一张图纸的话，那么样板文件就是制图规范，样板文件中规定了这个REVIT项目中各个图元的表现形式：线有多宽、墙该如何填充、度量单位用毫米还是用英寸等等，除了这些基本设置，样板文件中还包含了该样板中常用的族文件，如工业建筑的样板文件中，族里面便会包括一些吊车之类的只有在工业建筑中才会常用的族文件。 族文件： 官方解释：族是一个包含通用属性（称作参数）集和相关图形表示的图元组。属于一个族的不同图元的部分或全部参数可能有不同的值，但是参数（其名称与含义）的集合是相同的。族中的这些变体称作族类型或类型。 个人的理解：族文件可算是REVIT软件的精髓所在。初学者常常拿SKETCH UP中的组件来和REVIT中的族来做比较，从形式上来看，两者确实有相似之处，族可以看做是一种参数化的组件，如：一个门，在SKETCH UP中的一个门组件，门的尺寸是固定的，需要不同尺寸的门就需要再重新做一个，而REVIT中的一个门的族，是可以对门的尺寸、材质等属

Revit-2014-操作案例-操作手册范本

Revit操作案例——广联达案例工程 二、软件介绍 2.1菜单选项设置 双击打开软件，首先打开左侧主菜单栏，下角选项。可以设置文件保存时间、保存位置、界面颜色等常规设置。 保存时间：Revit中即时保存文件，根据保存时间存为不同版本，方便用户查看并使用不同的版本，所以我们保存时要建一个文件夹方便查看不同版本的文件。 保存位置：文件保存位置主要是项目 样板文件，项目文件以及族库的位 置，都是软件安装时默认的位置不建 议修改，如果自己自建样板和族时要 保存到库里以便后续使用。

绘图板颜色：正常打开时绘图板背景是白色的，不利于看图。在选项中图形颜色中选择反转背景色，就会变成黑色背景。 2.2应用程序菜单 提供对常用文件操作的访问，例如“新建”、“打开”和“保存”。还允许您使用更高级的工具（如“导出”和“发布）来管理文件。 单击打开应用程序菜单。 要查看每个菜单项的选择项，请单击其右侧的箭头。然后在列表中单击所需的项。作为一种快捷方式，您可以单击应用程序菜单中（左侧）的主要按钮来执行默认的操作。

最近使用的文档 在应用程序菜单上，单击“最近使用的文档”按钮，可以看到最近所打开文件的列表。使用该下拉列表可以修改最近使用的文档的排序顺序。使用图钉可以使文档始终留在该列表中，而无论打开文档的时间距现在多久。 打开的文档 在应用程序菜单上，单击“打开的文档”按钮，可以看到在打开的文件中所有已打开视图的列表。从列表中选择一个视图，以在绘图区域中显示。 快速访问工具栏 快速访问工具栏包含一组默认工具。您可以对该工具栏进行自定义，使其显示您最常用的工具。主要包括打开、保存、撤销、注释、字体、三维、剖面，切换视图等常用命令。 2.3软件操作 1.新建项目 新建项目有三种方式。第一种，打开软件初始界面有直接的新建项目。

revit 可视化编程插件Dynamo使用手册

Dynamo Language Manual

Contents 1. Language Basics 2. Geometry Basics 3. Geometric Primitives 4. Vector Math 5. Range Expressions 6. Collections 7. Functions 8. Math 9. Curves: Interpreted and Control Points 10. Translation, Rotation, and Other Transformations 11. Conditionals and Boolean Logic 12. Looping 13. Replication Guides 14. Collection Rank and Jagged Collections 15. Surfaces: Interpreted, Control Points, Loft, Revolve 16. Geometric Parameterization 17. Intersection and Trim 18. Geometric Booleans A-1. Appendix 1: Python Point Generators

Introduction Programming languages are created to express ideas, usually involving logic and calculation. In addition to these objectives, the Dynamo textual language (formerly DesignScript) has been created to express design intentions. It is generally recognized that computational designing is exploratory, and Dynamo tries to support this: we hope you find the language flexible and fast enough to take a design from concept, through design iterations, to your final form. This manual is structured to give a user with no knowledge of either programming or architectural geometry full exposure to a variety of topics in these two intersecting disciplines. Individuals with more experienced backgrounds should jump to the individual sections which are relevant to their interests and problem domain. Each section is self-contained, and doesn’t require any knowledge besides the information presented in prior sections. Text blocks inset in the Consolas font should be pasted into a Code Block node. The output of the Code Block should be connected into a Watch node to see the intended result. Images are included in the left margin illustrating the correct output of your program.

revit中的插件制作教程

我第一次的Revit 插件概述 您是欧特克Revit 电力用户变得更具生产力感兴趣吗？你想实现自动化或扩展的Revit，但计算机编程的新功能吗？如果是这样，那么本指南旨在为您。"我的第一个插件"是自学教程指南为编程世界顺利引入。这是用户知道欧特克公司的产品，但绝对新的编程和想学正冒险的"一站式商店"学习路径。在本指南中，您将工作与欧特克https://www.wendangku.net/doc/927017606.html, API 和C# 编程语言，但是如果你更喜欢的编程语言https://www.wendangku.net/doc/927017606.html, 我们提供了这种语言中的代码示例。 产品：Autodesk Revit * 编程语言：C# （和https://www.wendangku.net/doc/927017606.html,-不包括https://www.wendangku.net/doc/927017606.html, 代码样本的书面的解释） 应用程序编程接口(API)：https://www.wendangku.net/doc/927017606.html, API * 本指南是根据创建Autodesk Revit 建筑。本指南中的所有步骤都都适用于任何的Revit 三种口味的产品。本指南与2011或更高版本中，可以使用"Revit 结构"或"Revit MEP"替换所有"Revit 建筑"。版本2011和2012 我们提供工作与Visual Studio 工具的应用程序(VSTA) 里面的存档教训的说明下载、VSTA 已更换与SharpDevelop 的Revit 2013 。 概述 有许多资源可用在web 上为您了解Autodesk Revit API （应用编程接口），但是，这些资源往往为人已经知道编程设计。本指南是不同：它假定没有以前的编程知识，还可帮助您构建您的第一个插件快速，没有落得您的详细信息。你会在开始这种材料，不论您的编程专业的当前水平的一个小时内运行的应用程序。 指南将开始通过审查进展到覆盖的Autodesk Revit API 的使用经验教训上前自欧特克软件的好处。吸取的教训将开始通过建立工作的插件，才能覆盖更详细的解释的基本原则和进一步开发应用程序的功能。 自定义Autodesk Revit 的好处 在今天的世界中，我们鼓励你变得更有效率。这是自定义的一个主要好处：定制软件您使用在日常基础上精简工作流程提高您的效率。欧特克公司提供了功能强大的Api 和Sdk （软件开发工具包）使您可以通过定制它专门针对您的业务需要获得更大的价值，从您在欧特克软件的投资。 欧特克Revit 提供了一个丰富的API，可以用于自定义该产品的现有功能或通过添加全新的。可以自动执行重复性的、耗时的任务，无需离开Autodesk Revit 环境扩展核心功能。可以使用API 创建自定义工具和功能，直接插入Autodesk Revit，扩展其功能。 欧特克Revit 有一个.NET API，意味着您可以使用任何.NET 兼容的编程语言（C#、https://www.wendangku.net/doc/927017606.html,、 F # 等），开发插件。虽然每个语言都有自己的相对优势，C# 是本指南的天然选择：它是很容易学习、容易使用和利用基本的.NET 框架的力量。当你变得舒适与本指南-的内容和更熟练的C#-您将能够解决更为复杂的问题，在语言移动。 有时尽管C# 正在自然的选择，是何种语言，您可以在您的公司内工作与你控制范围之外的限制。编程语言https://www.wendangku.net/doc/927017606.html,发生非常接近第二次到C#，所以以容纳读者希望与欧特克Revit；在https://www.wendangku.net/doc/927017606.html,我们为您提供在https://www.wendangku.net/doc/927017606.html, 中的所有课代码。 编程可以是非常有益的。我们希望你那种感觉太完成这些教训之后。玩得愉快！ 摘要插件 "我的第一个插件"实现要复制一组（可以包含家具、隔断墙或机械电气水暖(MEP) 元素）的命令从一个房间到另一个。 它是很常见的建筑模型，以包含完全相同的家具布局和手动复制这些元素可以证明是耗时且乏味：它可以是有元素，例如保持相同的相对位置，很有挑战性。这种类型的任务非常适合用于Autodesk Revit API，通过自动化和本指南将带你通过这样做的过程。

Revit教程

Revit入门级小教程（原创~） 来源：张立名的日志 写在前面的前面： 这是寒假的一个作业，倪伟桥让我把我做的一个REVIT案例的详细过程写下来，所以就写了这么一篇类似教程的东西，既然写了就发上来分享一下，相信对于REVIT初学者还是有一些帮助的。同时希望大家能指出不足呀，我也用REVIT不久，也还有很多要学习的，欢迎分享心得经验~ 写在前面： REVIT作为一款专门面向建筑的软件，它的功能是非常强大的，它可以兼任辅助建筑设计和建筑表现两方面工作，以下所谈到的建模过程指的是建筑表现方面的工作，用REVIT辅助建筑设计需要设计者对REVIT建模有着非常熟练的掌握，相比于辅助建筑设计，对于初学者来说用REVIT来做建筑表现更加容易上手一些。因此以下所谈到的REVIT建模主要是针对建筑表现方面。 建模观念上的改变： REVIT作为一款BIM软件，它的建模跟我们平时常用到的建模软件，如SKETCH UP，RHINO 等，还是有着不小的差距的，要接受这款软件，在建模观念上就需要有一些改变。 如果把常用的SKETCH UP、RHINO比作手工模型的话，REVIT便可以比作实际建造，SKETCH UP、RHINO等软件的建模是通过形体的组成来完成，而REVIT的建模是通过组合不同的建筑元素来完成，如梁、柱、门、窗等等。既然是模拟实际建造，便有着实际建造的一些特点，如掌握建筑各部分精确的尺寸，了解建筑各部分材料的运用，构造做法等等，综合来说，用REVIT建模，必须对你的建筑方案有深入准确的了解，才可以建出一个完善的REVIT模型。这个观念对于一个刚刚接触REVIT的同学来说是很重要的，对自己的建筑方案了解的不够准确细致深入的话，建模的时候会碰到很多困难，让自己不得不停下手中的建模工作，来确定某一部分的尺寸、材料或构造等。REVIT模型的细致程度最终取决于设计者所做的方案的深度和对方案的了解程度。 两个重要的专有名词： 我从官方解释和我个人的理解两个方面来说一下对于REVIT中两个比较重要的专有名词的意思 样板文件： 官方解释：项目样板提供项目的初始状态。Revit Architecture提供几个样板，您也可以创建自己的样板。基于样板的任意新项目均继承来自样板的所有族、设置（如单位、填充样式、线样式、线宽和视图比例）以及几何图形。 个人的理解：如果把一个REVIT项目比作一张图纸的话，那么样板文件就是制图规范，样板文件中规定了这个REVIT项目中各个图元的表现形式：线有多宽、墙该如何填充、度量单位用毫米还是用英寸等等，除了这些基本设置，样板文件中还包含了该样板中常用的族文件，如工业建筑的样板文件中，族里面便会包括一些吊车之类的只有在工业建筑中才会常用的族文件。 族文件： 官方解释：族是一个包含通用属性（称作参数）集和相关图形表示的图元组。属于一个族的不同图元的部分或全部参数可能有不同的值，但是参数（其名称与含义）的集合是相同的。