Evolutionary Design

Getting Examples Ready

2012-02-18T04:28:00.000-08:00

Nothing particularly profound today, just an example of random form generation. I need to stock up on examples of these for the theme group I'll be running. Also need to find a good way to teach Ruby Scripting to those with no background at all in scripting.

2011-12-14T21:17:00.001-08:00

Am busy writing a section of the thesis on parametric modelling. I have the difficultly that, the term is quite vague and refers to many different practices - or occasionally different software. I made the slide below for a supervisor, to show the type of parametric modelling that we were interested in as we try to incorporate this into the Building Information Model. I'll do another post that covers the individual sections, as they get formalised.

Reptile Continued.

2011-12-05T08:05:00.000-08:00

Today's post is a video. Some coding done last night on another reaction of the Reptile project, this time, with spheres, which I'm trying to use as a way of keeping the model 'correct'

http://www.youtube.com/watch?v=SwVHI3eNIBg&feature=g-upl

Will soon combine this with a CA which shall correct some locals effects.

At the end of all this, different configurations of spheres are replaced by plates from the sides of a tetrahedron which form the structure.

More work on IFCs

2011-11-24T03:34:00.000-08:00

Spent the last week or so revising IFC - as we were planning on giving a little demonstration tomorrow.

The programs works as follows - an ANTLR parser reads in the IFC Express scheme and is used to create C# objects. While a better approach would be using tools designed for the job like the Eclipse Modelling Framework for Java, I was interested in staying in C# as well as adding more operations to various objects.

The IFC file is read and cast and reflect as C#objects and the properties are added from the file. The part I found tricky was with the SELECTION construct in Express, which is a little like an enumeration, but where you select from a list of object types, not just simple values like enum.

The demo made simple read in all objects that had inherited from 'IfcBuildingElement' and then showed its properties and then allowed you to add a new property set filled with single_value_properties.

4 axis grid

2011-10-04T02:59:00.000-07:00

More work on the 4 axis grid, this time, getting some points that lie on specific planes.

Sphere-Packing Grids

2011-10-03T07:08:00.000-07:00

Revisiting an a recurring theme - close sphere-packing. One of the interesting things that comes out of being here in this office, is that we're asked to consider alternative grids. In this case, it isa 4-axis one with axis {p,q,r,s} which make arranging spheres on the axis a lot tidier - i.e. something has the coordinate (1,1,1,0) instead of some irrational number.

With the color coding - the purple shows the traditional XYZ axis system, the light blue, green and orange the base plans in the grid and the dark blue, show the spheres that are on the P,Q,R,S individual axis

There still a tonne of tasks left on this experiment - have to find an abstraction for containment - like with parenthesis i..e. ((5+(3*2))*(1+1))

OpenGL Letter

2011-08-28T09:48:00.001-07:00

Finally got around to texturing quads with bitmaps created from True Type Fonts.

Been meaning to get that task done for quite awhile. It does take up quite a bit of resources doing things this way.

L-systems

2011-06-18T06:13:00.000-07:00

Back to old habits, have written so many l-system parsers, they always get harder to use as you try to add more features, so this time, I wrote the parser with ANTLR. Will add 3 basic shapes, rectangle, circle and equilateral triangle (for the reptile experiments.)

Was planning to move away from l-systems, but I think they are much easier to explain and make some headway with, on the design front, and for the sake of the first part of my thesis than the new grammar underway.

Design with the 4rth years

2011-05-24T01:29:00.000-07:00

An experiment done in class with the students, largely involving boolean subtractions.

Reaction-Diffusion Cont.

2011-05-15T09:18:00.000-07:00

With a lot of the graph visualization stuff working, I thought I'd spend today working on the Reaction-Diffusion component. Am feeling nervous about this representation type, as it is very sensitive to initial conditions - am trying to fix this, by having one cell in the chain which has an unusually high value, as the second image shows. this so far makes the graphs comparable, despite starting on completely random conditions.

Will have to keep playing with these systems as well as reading up more on RD systems - am finding the maths a bit scary though.

Palladio Cont.

2011-04-24T07:38:00.000-07:00

Some quick copy and pasting of the the code from some previous work - this is to check the adjacencies between spaces. This, the areas, and the proportions (of rectangular spaces) will be the fitness criteria for the next GA.

Palladio + DXF

2011-04-22T05:05:00.000-07:00

Spent quite a big part of today tracing over some Palladian plans and then saving them to DXF then adjusting my DXF reader. I wanted to get the areas of the rooms, and as some of them are irregular, I had to divide them into triangles and then add the areas up. Also found some weaknesses in my Binary Space Partitioning code - like it could only handle shapes drawn clock-wise - so had to make some adjustments there. Found an interesting algorithm, to determine if a set of points are running clock or anti-clockwise.

A google search will come up with the algorithm, to quote from the site:

"Sum over the edges, (x2-x1)(y2+y1). If the result is positive the curve is clockwise, if it's negative the curve is counter-clockwise. (The result is twice the enclosed area, with a +/- convention.)"

Here are the plans:

And the the triangulations and tests...

Splitting Cells

2011-04-18T05:23:00.000-07:00

Probably the most unimpressive image that I've ever uploaded. Had the realization that I've been too distracted with some of the core themes of my study. In this case, I'm going to move away from interpreting strings to create form, and instead focus on the interaction between cellular components. Hopefully this is a better form of creating emergent entities. The only problem is that it's much harder design incrementally and in smaller steps. In todays work, am working on a subsystem I'm calling it the 'signaler'- it's only function is to send signals to any component that it is connected to. Every cell also has the ability to 'split' into a self-similar copy of itself, but the child cell might have different characteristics.

Satolas Revisted

2011-04-11T09:06:00.000-07:00

Preparing for a guest lecture on Wednesday - going to show the kiddies how to model some Calatrava. Actually this is a project that I've wanted to model for a long time - I made an attempt in first year (2002!) Didn't really know much about modelling back then and had it set up as a single long, then mirrored. To capture the actual shape, multiple lofts are needed for individual surfaces as it looks planar in some positions, am still not entirely sure how the middle part is supposed to look as I can't get photographs from all directions of it. Anywho - it was fun modelling things in the 'traditional' way again! Too many generative algorithms and you start to lose your hand-eye coordination for modelling in 3D.

Within two minutes of uploading the post, I realized that the base was wrong - as it comes in sharply - had to make some adjustments to it to make it look more accurate!

Selecting in OpenGL

2011-03-25T05:59:00.001-07:00

Todays image doesn't really convey what the code was about - because it was a UI thing - selecting in openGL. For awhile its been bugging me as I didn't understand what the numbers that came out from the buffer meant. Basically in the buffer, is made up of set of 3 integers which refer to 2 measures of the z buffer followed by the name of the item (set with calling Glpushname(int n). The last item is the topmost one.

eplus objects continued

2011-03-19T07:30:00.000-07:00

A happy sight to see - have the classes being formed exactly as I want them to appear in my library. The IFC library is going to be a lot trickier though. Its good to get some practice in before I attempt that one.

More Graph Visualisation

2011-03-14T20:34:00.000-07:00

Had this idea, what if we were to visualise a BIM model as a graph. Doing some preliminary coding to see if anything will come out of this.

The algorithm below is the Reingold-Fruchterman, for visualization of graphs. The graph is a complete binary tree.

Geometry Library

2011-03-12T05:15:00.000-08:00

After two years of using a ad-hoc collection of classes home-made sitting all over the place, I've decided to start on a much nicer and neater geometry library which I'll keep in its own dll.

Have always copied files manually in the past as there were always so many bits missing.

Software Tools for Architectural Form with Jon Mirtschin

2011-03-10T21:44:00.000-08:00

My research partner Bianca is organizing a computational design group talk for the 24th of March. Anyone in Brisbane interested in computational design should come along. Was trying to figure out for ages why the name of the talker - seemed so familiar. It took a few days before I realized it was because I saw his geometrygym blog.

stupid grammars

2011-03-09T00:11:00.000-08:00

Had something that was usable enough working, but I wanted some of the comments to be grouped further, so they appear as I'd like them to in the generated class files.

At some point will have to stop and just grab the objects and then refine it later.

EnergyPlus Dictionary

2011-03-03T06:39:00.000-08:00

Stupid, stupid parser grammars, why are they always so hard to write? Was working on making a parser for the EnergyPlus dictionary so I could automatically create objects for them. It would have been a hundred times quicker to write one using switch case statements. Though the nice part is that you get cool diagrams coming out of ANTLR.

Tomorrow will reflect these into c# objects.

The nice thing about this all, is that when the new version of eplus comes out, will just have to read its dictionary to get all the new objects.

Splitting Walls

2011-02-27T00:52:00.001-08:00

Stopped working on the spatial planner code, to work on my Revit to EnergyPlus link. Was a frustrating weekend, just couldn't figure out, why the code wasn't working. I found that (going back to code from last year) my checkPointOnLine code only worked for 2D - and since I had only used it in 2D scenarios I didn't realise that. Then there were some rounding errors - I think the model is being sent too small, problem with all these metric to imperial conversion.

The problem I was facing was that when exporting a set of rooms from Revit, long walls that are in more than one room are sent as a single wall. In energy analysis, we only want heat gain from the area of the wall that is directly connected to that space. Hence the wall needs to be split into smaller segments. Then there has to be a search to see what room each of these smaller wall segments are in. Hopefully the next part, writing out the ePlus file will be easier, as I've already got some code to do that from a past experiment.

Adjacencies

2011-02-16T23:46:00.000-08:00

Took today as something of a rest-day. Was working on the graphics more and tweaking the algorithm to find the adjacent spaces to each space. When doing the colors, I kept thinking of that episode of scrubs, where the janitor is given a bright blue uniform and everyone stops being afraid of him (even Ted!) There's something about primary colors that puts us at ease.

Spatial planning cont.

2011-02-15T06:06:00.000-08:00

Okay, finally it looks like its getting somewhere. Its unbelievable how long, and how many lines of code it takes to create the images below, which look so simple in their primary colors. Now that this is over, the next step is to start making a framework for genetic algorithms that is good enough to last me through the rest of my research for this year - so it has to be quite general.

Still a bit of work before the shapes can be 'assessed' for fitness criteria, for starters, getting the room areas and adjacency graph needs to be implemented - I did some of that in a previous experiment.

the Battle continues

2011-02-14T08:01:00.000-08:00

Can't believe how long it took to get boundaries working. I must have typed a hundreds of 'if' statements, and the number of cases where the approach wouldn't work just kept increasing.

The idea was to have a 'tracker' start in one corner and keep going counter-clockwise until it reached the first cell. One problem is shown below in the brown shaped 'L' shape - what happens when the shape only consists of rows or columns? It reaches home without going up.

So I had to make for special exceptions - but it always seems so crude to keep having to place extra clauses - makes the algorithm seem a lot weaker.

Spatial Planning part 2 cont.

2011-02-12T22:13:00.000-08:00

Some more improvements. Advice for anyone doing this kind of thing - it really helps to be able to visualize the results quickly. In this case, cells that are completely inside, ie. all their neighbors are the same color, and each is connected to a neighbour if its the same color.

Spatial Planning part 2 cont.

2011-02-12T00:15:00.000-08:00

Success! Managed to have them grouped by color in an efficient manner using recursion. Though am now wondering where the process was that useful, given that I need to write something to get the boundary with all the segments joined up.

Spatial Planning part 2

2011-02-11T07:04:00.000-08:00

Making some major improvements to the spatial planning system that I blogged about awhile ago. Some of the changes include, using the 2D integer table to look up neighboring cells, instead of searching through everyone every time, like my last inefficient attempt.

Am working on joining all of the ones of similar colors together, which then form rooms.

Bar Graph

2011-02-02T00:54:00.000-08:00

Maybe I'm procrastinating on doing real work. Told someone that I'd work on some tools for visualizing results. Started with a bar graph, later will add surface plots, which will be useful when doing GAs. Its always slow having to code up something three dimensional.

Shading

2011-02-01T18:58:00.000-08:00

Need a real post soon, in the meantime, a quick one - looking at the specular and diffuse shading properties in opengl. In a way its strange that the quality is about as good as my raytracer without casting any rays!

Reaction-Diffusion 2

2011-01-07T14:40:00.001-08:00

Continuing with learning about reaction-diffusion systems. Am finally starting to feel comfortable numerically solving them. Have some problems with stability - if the discretizations aren't fine enough the values will very quickly head towards infinity.

Despite doing this in 2D, for most of my thesis, I'm only interested in 1D, periodic systems. The next task is to try and reverse engineer the constants needed to make certain values 'emerge.'

The point of this whole exercise is that the values being given off by the CA are emergent.

Reaction-Diffusion

2010-12-03T11:11:00.001-08:00

Haven't posted for a while now - the tasks just kept piling up. Probably not the most dramatic image - but simulates something I've been interested in for awhile - reaction-diffusion patterns. The initial condition is completely random - it then self organizes to form peaks. Will try to move this to 2D later during the weekend.

Visualising Graphs

2010-10-17T21:36:00.000-07:00

This is an update to a previous post - using the Fruchterman-Reingold algorithm to arrange the graphs. Took a lot longer than what it should have - I was expecting to just have to add a third dimension value to all the vertex and edge classes, but for ages could not get it to look right.

In the example shown below, a complete binary tree is used as the graph. Will try a later on with some polyhedra or 'buckyballs.' The aim of this experiment is to have a single cell multiply itself out dozens of times, and then to have each of the resultant cells differentiate themselves entirely on their position and local characteristics. Its going to very quickly reach a state where I can't explicitly define a form. Which makes the work exciting.

First Post

2010-10-14T09:46:00.000-07:00

My last blog began with a recreation of a commonly seen L-system. This time, I'm starting with a recreation of a famous 1dimensional cellular automata - Rule 30. Its quite interesting how the automata are named. The operations are recorded as 8 bits, which in turn spell out a number, in this case '30'. The simplest example of emergent complexity. One thing I don't like about 1D CA's is that they distinuish between left and right, as opposed to most 2D ones like Conways game of life, which only count the number of neightbours So in a way, the complexity seen in Rule 30 comes about from treating the left and right different.

The main reason for leaving the last blog was that I've moved away from L-systems and am now working on a type of finite automata which have a greater expressive power and also don't depend on having to read a string everytime all the geometry needs to be redrawn.