PhD student Sebastian Gmelin, Prof. Kristian Agger, Aarhus School of Architecture – Double curved surfaces became common practice in architectural design. While their digital creation is well supported through a wide range of computer software, crafting them remains a specialist task – expensive and laborious. Building information modeling (BIM) lifts computer drawings from being pure geometrical descriptions to a representation of real building objects. It will be researched to use the additional information supplied to create complex geometry within a certain range of parameters, given by a specific construction material or structural system. The result will not only be a geometrical shape but also a specific construction method or even a set of interacting forces. B-processor is an open-source BIM software, currently being developed by the Aarhus School of Architecture (Prof. Kristian Agger) and the Alexandra Institute (Michael Lassen). It creates a platform to develop modeling tools as described above and will form the base for the PhD thesis.
The first attempts to create curved objects in B-processor lead to the following conclusions:
Any curved object will need a series of input parameters usually called control vertices, control polygon or control mesh
This input is used to compute the curve from an algorithm
There is a desire to change the parameters after the curve was computed. This means the object should provide the flexibility to redraw itself once an input parameter changed.
It was discussed that this problem could be described more generally as a parametric object providing the following functionality and parameters:
The object is a group of elements: geometrical input, additional parameters, a script (i.e. the algorithm computing a curve) and the resulting geometry
The script would be run each time of the input parameters (geometrical or additional) is changed.
Rerunning the script recomputes the resulting geometry. In the case of B-processor this means to delete the previous result and redraw the geometry. It was discussed to only redraw local changes instead of the complete geometry but this will rather be a later optimization.
All element parts are organized within the object browser as children of the main geometry object, allowing the user easy access.
The geometry parameters of the object will be realized using the existing B-net functionality.
The attached scripts should be Java scripts to allow full functionality and access to all methods and properties. In a second step a scripting languages “B-script” could be implemented, allowing the creation of simple scripts.
The object should be set up very flexibly, i.e. an object should be allowed to create new objects or being the input for other objects (lofts, sweeps…)
In Eclipse, right-click on the main project folder and chose >team< … >update< in the context menu. This will upload changes other users made into your local code copy.
Start Cygwin shell, and direct to your workspace folder
c:
cd Users/[…]/workspace/build
run the batch build command “./build.sh clean dist”
In Eclipse, right/click on the main project folder and chose >refresh< in the context menu.
Chose >Project< in the main menu bar and >clean< the project
Right-click on the main project folder (or changed folder) and chose >team< … >commit< to commit your changes to the server copy of the code.
List<Vertex> vertices = new ArrayList(net.getVertices());
List<Edge> edges = new ArrayList(net.getEdges());
List<Vertex> orderPoints = new ArrayList();
List<Vertex> curvePoints = new LinkedList();
if (vertices.size()>=3) {
LinkedList<Edge> nEdges = new LinkedList();
nEdges = (LinkedList) order(edges);
// write into List
for (int i=0; i<nEdges.size(); i++) {
orderPoints.add(nEdges.get(i).from);
}
orderPoints.add(nEdges.get(nEdges.size()-1).to);
// make Spline go through endpoints
for (int i=0; i<=2; i++) {
orderPoints.add(orderPoints.get(orderPoints.size()-1));
orderPoints.add(0,orderPoints.get(0));
}
// create space object to draw new elements
Space result = Space.createUnion(UNRBSname); // calculate Uniform Nonrational Spline Curve
for (int i=3; i<= orderPoints.size()-2; i++) {
for (int t=0; t<subdiv; t++) {
curvePoints.add(unrbsCalc(orderPoints.subList(i-3, i+1),t/subdiv));
}
}
// draw Spline Curve
for (int i=1;i<curvePoints.size()-1;i++) {
result.add(new Edge(curvePoints.get(i-1),curvePoints.get(i)));
}
The research plan for this project was now handed in for approval with the research committee of the Aarhus School of Architecture.
It contains the following chapters and sections and can be downloaded as a pdf at the bottom of this post.
1 Abstract
2 Definitions
2.1 Building Information Modelling (BIM)
2.2 B-processor
2.3 Project title
3 Project description
3.1 Hypothesis
3.1.1 BIM software can be used as an intuitive and intelligent design tool
3.1.2 Material elasticity can be used to simply and cheaply build double curved surfaces
3.1.3 Elastic deformation simulation can be integrated in BIM software as intuitive design tools
3.1.4 Further parameters can be used for design tools in a similar way
3.2 Problem
3.2.1 Complex geometry – design to production
3.2.2 B-processor – curved surfaces
5.1 Curved geometries and their computational representation (research module 1)
5.2 Simulation parameters (research module 2)
5.3 B-processor and Java scripting (research module 3)
5.4 Case studies
5.4.1 Material Elasticity
5.4.2 Structural Systems
5.4.3 Selfshading surfaces
5.4.4 Space solving
5.4.5 Acoustic surfaces
6 Context
6.1 Practical relevance and reason for double curvature
6.2 Research context
6.2.1 Chair of Digital Fabrication (Prof. Gramazio and Prof. Kohler) ETH, Zurich
6.2.2 Chair of CAAD (Computer Aided Architectural Design, Prof. Hoverstadt) ETH, Zurich
6.2.3 Centre for Information Technology and Architecture, CITA (Mette Ramsgard Thomsen), Copenhagen
7 Education background and interest in complex geometry
8 Supervision
8.1 Work and research setup
8.2 Supervision extent
Rephrasing a project title as a strategic decision
Having started my PhD only a few months back, it feels as if I am really at the beginning of my research. This is probably a common feeling as well as a correct statement and it led to the question whether I made any research relevant decision I could write about so far or if I was just collecting information and trying to understand the process and the project my work will be embedded in. The answer is that I permanently made decisions influencing my “research path” by choosing which articles to read, which people to talk to (or not) and by redefining the main objective of my project.
The most interesting, influencing and challenging decision though, was to adjust the original title of my PhD from “Komplex Geometry – B-processor” into “Complex geometry in architecture based on building information modeling”. And it is almost amusing how simply rephrasing the title, freed my mind and turned a – without doubt challenging – task into a research project. It might also serve as an example of how I try to make judgment on questions and take decisions for my PhD.
B-processor is – simply put – CAD software. It is also a research project of the Arhus school of architecture in cooperation with Alexandra Institute, investigating new ways of integrating building information modeling (BIM) in an architectural design workflow. B-processor was developed from scratch as all existing packages seemed to be too restrictive. This led of course to a rather slow development process not only because any object or tool had to be programmed but also designed, discussed and reviewed. Today B-processor works as a very simple and intuitive tool but it is missing elementary functionality to be tested in real life. This is the lack of any curved element: from arcs to freeform surfaces.
Before being able to work on any complex geometry a lot of ground work will need to be done by implementing an extended object structure in B-processor, allowing curved surfaces of any kind. This will affect existing tools and objects because all of them need to interact (to be trimmed, intersected, copied, etc.) The risk is to get lost in a task that cannot be defined as research, is time consuming and could better be done by a real programmer than a researching architect with programming skills. At the same time, it offers the opportunity to develop B-processor in a way and direction that allows complex geometry to be created in a new way. Looking for these new workflows and questioning how curved surfaces are created in software so far can therefore become research. This thin line between a programmer’s homework and a research project will constantly need to be checked.
The decision I made was to widen the field on the one hand side and narrowing it down on the other. Instead of researching complex geometry in B-processor I first decided to research complex geometry in building information modeling in general. This will allow me to look at B-processor as one specific BIM tool with certain advantages and disadvantages. It might fail to use B-processor in the intended way and I could still research using other software. It also means that the basic work in B-processor can be done in parallel to a general research that is not necessarily depended on the outcome of the task of implementing curves and still creates valid research outcome.
There are still many reasons for not abandoning B-processor completely from my research project. I see it as a prepared ground that is ready for almost any seed to be planted. It is a relatively unknown project that I could form in the way I can make the most use of it.
Secondly I narrowed down complex geometry in general to “complex geometry in architecture”. It might seem like a minor change but it helps me to exclude all the freeform modeling fields that rather deal with visualization and animation and is important because so far, architects tend to use tools that originally were created for other purpose (movie, car and airplane industries). I however would like to focus on architecture-specific tools and workflows.
In combination, the two phrases also exclude the formal questions why complex geometry is used in architecture at all. My research starts at the point when a decision for double curvature is made and concentrates on ideal workflows from design to production instead of questioning the reasons. I don’t think that looking at the tectonic derivation of a specific architectonic shape isn’t worth a research project it is rather a project on its own. Again a decision was made towards a more technical approach, excluding (or better minimizing) the formal background. The hypothesis that an intuitive and optimized workflow to create this kind of geometry is independent from the formal reasons might though need to be looked at.
Last but not least I replaced the simple hyphen in the title with “based on”. Even though I am not yet fully satisfied with this, it is a step in the right direction as it starts defining how the two elements, “complex geometry” and “B-processor” or “building information modeling” should interact. The question I would like to research is how the use of building information modeling changes and influences the workflow of creating complex geometry.
The essence of the above process is that I made quite a strategic judgment. The decision opens up a wide range of possibilities and new research directions while it narrows it down on the other side to limit options and not getting lost in a jungle of too many potential directions. I guess it will often need this kind of decision to balance the specific and the general. And it will be exciting to see how quickly a chosen path can be evaluated.
It seems to be a process of trying to steer the right way while reaching a dead end is not a failure of research rather than an exclusion of one possible solution. It is also a strategy of breaking the problem into solvable parts, a method of temporarily narrowing the range of directions and to focus on a more specific problem before looking at the big picture again.
I also decided to work in parallel on different questions as it can be quite frustrating, being stuck with a certain problem. A solution often can’t be forced. Switching track and working on something different is a trick to re-motivate myself and can potentially untie a “mental knot”.
I envisage to theoretically investigate on complex geometry and building information modeling and to sketch potential ways of how the two can be joined to create new workflows.
The results will be evaluated and if found to be promising translated into case studies in either B-processor or another software. This will allow testing as a form of evaluation. The results of the case studies will hopefully drive the next level of theoretical decisions.
Wrote a simple script that simulates chain models in Microstation. A series of chain segments of a specific length is defined. Some knots are fix others can move.
‘Simulation of a chain model
‘Sebastian Gmelin
‘15.11.2009
Option Explicit
Const gravity As Double = 1 / 5
Const springforce As Double = 1 / 8
Const attrForce As Double = 3
Public Type sphere
number As Long
radius As Double
center As Point3d
newCenter As Point3d
sElements(3) As Element
numNeighbours As Long
Neighbours(10) As Long
connections(10) As Element
moveable As Boolean
End Type
Dim spheres() As sphere
Function createSphere(pos As Point3d, rad As Double, number As Long, moveable As Boolean) As sphere
Dim elem As Element
Dim mat As Matrix3d
createSphere.center = pos
createSphere.newCenter = pos
createSphere.radius = rad
createSphere.moveable = moveable
createSphere.number = number
createSphere.numNeighbours = 0
Set elem = CreateLineElement2(Nothing, pos, pos)
elem.Color = 3
If moveable Then elem.Color = 1
elem.LineWeight = 8
elem.LineStyle = ActiveDesignFile.LineStyles(1)
ActiveModelReference.AddElement elem
elem.Redraw
Set createSphere.sElements(0) = elem
mat = Matrix3dFromAxisAndRotationAngle(2, 0)
Set elem = CreateEllipseElement2(Nothing, pos, rad, rad, mat, msdFillModeNotFilled)
elem.Color = 6
elem.LineWeight = 0
elem.LineStyle = ActiveDesignFile.LineStyles(2)
ActiveModelReference.AddElement elem
elem.Redraw
Set createSphere.sElements(1) = elem
mat = Matrix3dFromAxisAndRotationAngle(1, Pi / 2)
Set elem = CreateEllipseElement2(Nothing, pos, rad, rad, mat, msdFillModeNotFilled)
elem.Color = 6
elem.LineWeight = 0
elem.LineStyle = ActiveDesignFile.LineStyles(2)
ActiveModelReference.AddElement elem
elem.Redraw
Set createSphere.sElements(2) = elem
mat = Matrix3dFromAxisAndRotationAngle(0, Pi / 2)
Set elem = CreateEllipseElement2(Nothing, pos, rad, rad, mat, msdFillModeNotFilled)
elem.Color = 6
elem.LineWeight = 0
elem.LineStyle = ActiveDesignFile.LineStyles(2)
ActiveModelReference.AddElement elem
elem.Redraw
Set createSphere.sElements(3) = elem
End Function
Sub moveSphere(s As sphere, vec As Point3d)
Dim i As Long
s.center = Point3dAdd(s.center, vec)
For i = 0 To UBound(s.sElements)
Call s.sElements(i).Move(vec)
s.sElements(i).Rewrite
s.sElements(i).Redraw
‘ActiveDesignFile.Views(1).Redraw
Next i
End Sub
Sub moveConnections()
Dim s As Long
Dim c As Long
For s = 0 To UBound(spheres)
For c = 0 To spheres(s).numNeighbours – 1
Call spheres(s).connections(c).AsLineElement.ModifyVertex(0, spheres(s).center)
Call spheres(s).connections(c).AsLineElement.ModifyVertex(1, spheres(spheres(s).Neighbours(c)).center)
spheres(s).connections(c).Rewrite
spheres(s).connections(c).Redraw
Next c
Next s
Dim elem As Element
Dim points(1) As Point3d
Dim i As Long
For i = 0 To spheres(s).numNeighbours – 1
points(0) = spheres(s).center
points(1) = spheres(spheres(s).Neighbours(i)).center
Set elem = CreateLineElement1(Nothing, points)
elem.Color = 2
elem.LineWeight = 2
elem.LineStyle = ActiveDesignFile.LineStyles(1)
ActiveModelReference.AddElement elem
elem.Redraw
Set spheres(s).connections(i) = elem
Next i
End Sub
Sub calculateSphereMove(s As Long)
Dim i As Long
Dim k As Long
Dim direction As Point3d
Dim dist As Double
Dim length As Double
Dim grav As Boolean
Dim vec As Point3d
Dim tension As Double
If spheres(s).moveable Then
tension = 0
For i = 0 To spheres(s).numNeighbours – 1
direction = Point3dSubtract(spheres(spheres(s).Neighbours(i)).center, spheres(s).newCenter)
dist = Abs(Point3dMagnitude(direction))
‘Debug.Print (”distance ” + CStr(dist))
length = spheres(s).radius + spheres(spheres(s).Neighbours(i)).radius
‘Debug.Print (”length ” + CStr(length))
tension = tension + dist – length
Next i
tension = tension / (spheres(s).numNeighbours)
grav = True
If tension > 0 Then
spheres(s).newCenter = Point3dAdd(spheres(s).newCenter, Point3dFromXYZ(0, 0, -0.1 * gravity))
Else
spheres(s).newCenter = Point3dAdd(spheres(s).newCenter, Point3dFromXYZ(0, 0, -1 * gravity))
End If
vec = Point3dFromXYZ(0, 0, 0)
For i = 0 To spheres(s).numNeighbours – 1
direction = Point3dSubtract(spheres(spheres(s).Neighbours(i)).center, spheres(s).newCenter)
dist = Abs(Point3dMagnitude(direction))
‘Debug.Print (”distance ” + CStr(dist))
length = spheres(s).radius + spheres(spheres(s).Neighbours(i)).radius
‘Debug.Print (”length ” + CStr(length))
If (dist – length) > 0 Then
grav = False
direction = Point3dScale(direction, attrForce * springforce * (dist – length) / (dist))
Else
direction = Point3dScale(direction, springforce * (dist – length) / (dist))
End If
vec = Point3dAdd(vec, direction)
Next i
spheres(s).newCenter = Point3dAdd(spheres(s).newCenter, vec)
End If
End Sub
Sub moveSpheres()
Dim i As Long
Dim s As Long
Dim vec As Point3d
For s = 0 To UBound(spheres)
vec = Point3dSubtract(spheres(s).newCenter, spheres(s).center)
spheres(s).center = spheres(s).newCenter
For i = 0 To UBound(spheres(s).sElements)
Call spheres(s).sElements(i).Move(vec)
spheres(s).sElements(i).Rewrite
spheres(s).sElements(i).Redraw
‘ActiveDesignFile.Views(1).Redraw
Next i
Next s End Sub
Sub Main()
Dim i As Long
Dim k As Long
Dim s As Long
Randomize
ReDim spheres(99)
For i = 0 To 9
For k = 0 To 9
spheres(i * 10 + k) = createSphere(Point3dFromXYZ(i, k, 0), 0.65, i * 10 + k, True)
Next k
Next i
For i = 0 To 9
For k = 0 To 9
’spheres(i * 10 + k) = createSphere(Point3dFromXYZ(i, k, 0), rnd * 0.2 + 0.5, i * 10 + k, True)
If i < 9 Then
spheres(i * 10 + k).Neighbours(spheres(i * 10 + k).numNeighbours) = i * 10 + k + 10
spheres(i * 10 + k).numNeighbours = spheres(i * 10 + k).numNeighbours + 1
End If
If k < 9 Then
spheres(i * 10 + k).Neighbours(spheres(i * 10 + k).numNeighbours) = i * 10 + k + 1
spheres(i * 10 + k).numNeighbours = spheres(i * 10 + k).numNeighbours + 1
End If
If i > 0 Then
spheres(i * 10 + k).Neighbours(spheres(i * 10 + k).numNeighbours) = i * 10 + k – 10
spheres(i * 10 + k).numNeighbours = spheres(i * 10 + k).numNeighbours + 1
End If
If k > 0 Then
spheres(i * 10 + k).Neighbours(spheres(i * 10 + k).numNeighbours) = i * 10 + k – 1
spheres(i * 10 + k).numNeighbours = spheres(i * 10 + k).numNeighbours + 1
End If
Call drawConnections(i * 10 + k)
Next k
Next i
For i = 0 To 75
‘ Call moveSphere(spheres(Round(Rnd * 99)), Point3dFromXYZ(0, 0, Rnd * 0.5 – 0.25))
‘ Call moveConnections
For s = 0 To UBound(spheres)
Call calculateSphereMove(s)
Next s
Call moveSpheres
Call moveConnections
ActiveDesignFile.Views(1).Redraw
Next i
Hyperbolic paraboloids (HP) are discribed by the formula
The below script creates HPs in Microstation within a certain range of x and y coordinates. The dashed lines indicate the regular grid on coordinate system. These are of parabolic shape. The thick diagonal lines are all straight. They are the reason why this shape is interesting for construction, as it can be discribed as a series of straight lines. Intersecting the surface with a horizontal plane creates hyperbolas (blue curves).
For x = range * -1 To range
For y = range * -1 To range
points(y + range) = hp(x + range, y + range)
Next y
Set ele = CreateLineElement1(Nothing, points)
ele.Color = 4
ele.LineWeight = 0
ActiveModelReference.AddElement ele
ele.Redraw
Next x
For y = range * -1 To range
For x = range * -1 To range
points(x + range) = hp(x + range, y + range)
Next x
Set ele = CreateLineElement1(Nothing, points)
ele.Color = 4
ele.LineWeight = 0
ActiveModelReference.AddElement ele
ele.Redraw
Next y
End Sub
Sub drawDiaGrid()
Dim points() As Point3d
Dim i As Long
For i = 1 To range * 2
x = range * -1
ReDim points(i)
For y = range – i To range
points(y – range + i) = hp(x + y + i, y + range)
Next y
Set ele = CreateLineElement1(Nothing, points)
ele.Color = 7
ele.LineWeight = 1
ActiveModelReference.AddElement ele
ele.Redraw
For y = i To 0 Step -1
points(i – y) = hp(i – y, y)
Next y
Set ele = CreateLineElement1(Nothing, points)
ele.Color = 7
ele.LineWeight = 1
ActiveModelReference.AddElement ele
ele.Redraw
If i < range * 2 Then
y = range * -1
ReDim points(range * 2 – i)
For x = range * -1 + i To range
points(x + range – i) = hp(x + range, y + range * 2 + x – i)
Next x
Set ele = CreateLineElement1(Nothing, points)
ele.Color = 7
ele.LineWeight = 1
ActiveModelReference.AddElement ele
ele.Redraw
y = range
ReDim points(range * 2 – i)
For x = range * -1 + i To range
points(x + range – i) = hp(x + range, y – x + i)
Next x
Set ele = CreateLineElement1(Nothing, points)
ele.Color = 7
ele.LineWeight = 1
ActiveModelReference.AddElement ele
ele.Redraw
End If
Next i
End Sub
Sub horizontalCut(cz As Double)
Dim points() As Point3d
Dim pointsNeg() As Point3d
If cz >= 0 Then
For y = range * -1 To range
x = Math.Sqr(a * a * (((y * y) / (b * b)) + 2 * cz))
points(y + range) = Point3dFromXYZ(x, y, cz)
pointsNeg(y + range) = Point3dFromXYZ(-1 * x, y, cz)
Next y
Else
For x = range * -1 To range
y = Math.Sqr(b * b * (((x * x) / (a * a)) – 2 * cz))
points(x + range) = Point3dFromXYZ(x, y, cz)
pointsNeg(x + range) = Point3dFromXYZ(x, -1 * y, cz)
Next x
End If
Set ele = CreateLineElement1(Nothing, points)
ele.Color = 5
ele.LineWeight = 2
ActiveModelReference.AddElement ele
ele.Redraw
Set ele = CreateLineElement1(Nothing, pointsNeg)
ele.Color = 5
ele.LineWeight = 2
ActiveModelReference.AddElement ele
ele.Redraw
End Sub
Sub Main()
ReDim hp(range * 2, range * 2)
For x = range * -1 To range
For y = range * -1 To range
z = (((x * x) / (a * a)) – ((y * y) / (b * b))) / 2
point = Point3dFromXYZ(x, y, z)
Set ele = CreateLineElement2(Nothing, point, point)
ele.Color = 3
ele.LineWeight = 10
ActiveModelReference.AddElement ele
ele.Redraw
hp(x + range, y + range) = point
Next y
Next x
I started reading on Curve models and geometries, different types of Spline algorithms. This is a first attempt to generate Bezier curvers using the algorithm of de Casteljau. The script uses a selected polyline as the control polygon of the curve. The Bezier is created in several steps to illustrate the process. It runs under Microstation MVBA.
Bezier curve of degree 3
Bezier curve of degree 4
Bezier curve of degree 5
Bezier curve of degree 8
‘Linestring Bezier Approximation after Casteljau’s algorithm
‘Sebastian Gmelin
‘24.10.2009
‘draw and select linestring and run script
Const cDiv As Long = 5 ’subdivision at which guidlines are drawn and a copy of the drawing set is created
Const div As Long = 50 ’subdivision between cDiv for bezier spline points (total subdivision = cDiv * div)
Dim cPoints() As Point3d
Dim bPoints() As Point3d
Dim cSize As Point3d
Dim cLine As Element
Private Sub ScanDesignFile()
’scan active designfile for selected linestrings
Dim oElEnum As ElementEnumerator
Dim oElem As Element
‘get collection of selected elements
Set oElEnum = ActiveModelReference.GetSelectedElements
ActiveModelReference.UnselectAllElements
‘go through selection set
While oElEnum.MoveNext
Set oElem = oElEnum.Current
‘check if active element is linestring
If (oElem.IsVertexList) Then
Debug.Print (”Linestring”)
cPoints = oElem.AsVertexList.GetVertices ’save collection of vertices
Set cLine = oElem
End If
Wend
End Sub
Private Sub getSize()
‘get linestring size for element copies offset
Dim i As Long
Dim min As Point3d
Dim max As Point3d
Dim lineString As Element
min = Point3dFromXYZ(1E+17, 1E+17, 1E+17)
max = Point3dFromXYZ(-1E+17, -1E+17, -1E+17)
For i = 0 To UBound(cPoints)
If cPoints(i).X > max.X Then max.X = cPoints(i).X
If cPoints(i).Y > max.Y Then max.Y = cPoints(i).Y
If cPoints(i).Z > max.Z Then max.Z = cPoints(i).Z
If cPoints(i).X < min.X Then min.X = cPoints(i).X
If cPoints(i).Y < min.Y Then min.Y = cPoints(i).Y
If cPoints(i).Z < min.Z Then min.Z = cPoints(i).Z
Next
Dim i As Long
Dim k As Double
Dim p As Long
Dim points() As Point3d ‘last parent point collection
Dim dPoints() As Point3d ‘division points
Dim mPoints() As Point3d ‘points to draw
Dim lineString As Element
Dim color As Long
Dim count As Long
Dim moveCount As Long
For k = 1 / (div * cDiv) To 1 Step 1 / (div * cDiv) ‘k is scale factor of divisions
points = cPoints
dPoints = cPoints
color = 48
‘calculate divisions
While UBound(dPoints) > 1
‘points is the collection of vertices of the parent linestring
‘dPoints is the child linestring at scalefactor k
For i = 0 To UBound(points) – 1
dPoints(i) = Point3dAdd(Point3dScale(Point3dSubtract(points(i + 1), points(i)), k), points(i))
Next i
ReDim Preserve dPoints(UBound(points) – 1)
‘draw guidlines
If count = div Then
mPoints = dPoints
‘calculate offset
For p = 0 To UBound(mPoints)
mPoints(p) = Point3dAdd(mPoints(p), Point3dScale(cSize, moveCount))
Next
‘draw line
Set lineString = CreateLineElement1(Nothing, mPoints)
lineString.color = color
lineString.LineStyle = ActiveDesignFile.LineStyles(3)
ActiveModelReference.AddElement lineString
lineString.Redraw
color = color + 48
End If
points = dPoints
Wend
count = count + 1
‘draw progress of bezier curve
If count > div Then
count = 0
‘copy control polygon
Set lineString = ActiveModelReference.CopyElement(cLine)
Call lineString.Move(Point3dScale(cSize, moveCount))
ActiveModelReference.AddElement lineString
lineString.Redraw
moveCount = moveCount + 1
‘calculate offset of beziers pline
mPoints = bPoints
For p = 0 To UBound(mPoints)
mPoints(p) = Point3dAdd(mPoints(p), Point3dScale(cSize, moveCount – 1))
Next
‘draw bezier progress
Set lineString = CreateLineElement1(Nothing, mPoints)
lineString.color = 3
lineString.LineWeight = 2
ActiveModelReference.AddElement lineString
lineString.Redraw
End If
‘add calculated division point to collection of bezier points
ReDim Preserve bPoints(UBound(bPoints) + 1)
bPoints(UBound(bPoints)) = Point3dAdd(Point3dScale(Point3dSubtract(points(1), points(0)), k), points(0))
Next k
‘draw final bezier curve
mPoints = bPoints
For p = 0 To UBound(mPoints)
mPoints(p) = Point3dAdd(mPoints(p), Point3dScale(cSize, moveCount – 1))
Next
Set lineString = CreateLineElement1(Nothing, mPoints)
lineString.color = 3
lineString.LineWeight = 2
ActiveModelReference.AddElement lineString
lineString.Redraw
End Sub
Sub Main()
If ActiveModelReference.AnyElementsSelected Then
ScanDesignFile
getSize
Casteljau
End If
