Quantcast
Channel: CAD, BIM & 3D
Viewing all 67 articles
Browse latest View live

ifcGears : Open Source IFC Library/Framework & Viewer

$
0
0
ifcGears (http://www.ifcgears.com)

This is a C++ Open Source library, providing a framework to generate IFC reader/writer classes from the Express files.

In addition, there is an IFC Viewer program, using OpenSceneGraph or OSG (http://openscenegraph.org) and Nokia Qt SDK (http://qt.nokia.com).

Compilation Issues

I was able (after some serious struggle) to compile the ifcGears library and the ifcGearsViewer on OSX.
It uses the CMake build system (http://cmake.org) which has support for OSG. But the GUI-version of CMake on OSX does not properly generate all settings, as it seems to miss the environment variables somehow. When generating the XCode project or the Makefiles using cmake from the command line, things run smoother.

Anyway, if you use the graphical CMake, you have to ensure that all libraries are found. I have only used the release-versions.

With the OPT_VIEWER you can optionally enable the generation of the IFC Viewer too, but you need OpenSceneGraph installed properly (which was also a bit of a problem on OSX, but I'll skip that in this post). I used version 3.0.1. In addition, you also need Qt available (qmake etc...). I used version 4.7.

All was compiled for 64-bit (x86_64) for Intel and using Cocoa (native) instead of Carbon (deprecated), but it should be possible to make 32-bit versions for PPC and Intel too.




With all of that into place, I was able to compile the library and the viewer.




The red commands are probably due to the IFC-version used when exporting the model from ArchiCAD. I am not worrying too much here, as I have to test more.

I see no Windows or Doors and some walls are apparently not visible. When trying a single wall with a door and a window, the openings got hidden beneath the closed wall geometry, so more work seems to be required.

IFC-SDK : Open Source IFC 2x3 Library

$
0
0
IFC-SDK
Formerly: http://www.osor.eu/projects/ifc-sdk
Moved in Dec 2011 to https://joinup.ec.europa.eu/software/ifc-sdk/home

This is an Open Source C++ library for reading and writing IFC files. It does not depend on any external libraries and can be compiled on most modern compilers. It was tested on Windows (g++ and VC++ 2003+2005) and on Linux (g++ 3 and 4).
I had no problem compiling it on OSX Snow Leopard, using XCode 3.2.5.

It contains a STEP library and an IFC library, alongside a quite large list of example programs, including tests, to explain the features of the library.

Using CMake it could compile the full library without problems and the example programs seem to work fine. They are all command-line, so no GUI problems, but nothing fancy to see either.


However, there are some caveats...
  • I see very little actual information (project homepage, author and licensing details).
    • however, inside the source code, it is "copyrighted 2009 CSTB" and released under the LGPL 2.1 license, which is Open Source, but with the possibility to link it in a commercial software.
  • Last update was in October 2009, which is a bad sign... as it seems to not be (publicly) maintained. It is numbered 1.0-beta.
  • The library is made for IFC 2x3 which is not the current version of the IFC standard.
  • Most of the included examples focus on the geometric aspects and not the building information
    • ifcRevolvedAreaSolid_app (see above)
    • ifcVector_app
    • ifcShellBasedSurfaceModel_app etc...
So if anybody has more details about it and if a more recent version is available, then please comment.

Open IFC Tools : Open Source IFC Libraries and software

$
0
0
Open IFC Tools (http://www.openifctools.org)

This is a set of Open Source (for non-commercial use) libraries written in Java. It should work on Windows, Linux and OSX.

They follow a modular approach, where different packages are being released in order:

  1. Open IFC Java Toolbox
  2. Boolean Modeller
  3. IFC-loader for Java3D
  4. 4D Scheduling Assistant
Currently, only the Toolbox is available, together with a Java Webstart demonstration to launch the software directly from a browser. This automatically installs the necessary extensions for Java3D, OpenGL, GlueGen.

I tried the web-demo but first had to update Java3D on my Mac (as mentioned on http://www.openifctools.org/Open_IFC_Tools/mac_java3d.html).


This viewer loaded the ArchiCAD file without problems and displayed it adequately. You get a view on the actual IFC code, a 3D visualization, the hierarchic object tree of the Spatial structure and the particular attributes of selected entities, which is exactly what you need from a viewer.

The yellow color is the highlight color of the wall I selected, on the ground floor ("Gelijkvloers" in Dutch). It displays the wall information, the ID (unique), the Name (as named inside ArchiCAD) and the connectivity with other objects.

This is quite comparable to what is provided by Solibri Viewer, so the implementation is fairly complete.

For an end user, you might be a bit scared away with all the nitty-details from the IFC files and indeed, a literal display of what is inside an IFC file can be pretty daunting, when you are accustomed to a more user-friendly display from e.g. ArchiCAD or Revit.

Working in the cloud with free software

$
0
0
This post comments briefly on some of the "cloud"-enabled software utilities that I have started to use more and more. Short definition: these apps will allow you to work from different computers or devices on your data, yet are more optimized and user-friendly than a web page, despite the javascript goodness that seems to flood many new "organizer" and "authoring" and "managing" projects.

I'll discuss Dropbox, Evernote, Skitch and Mendeley Desktop. Not CAD this time, but usable and free utilities that I have start to rely on, almost every day.

Dropbox
(register using this link to give you and me some more space)

This one is quite popular. You want to access your files from different places and possibly share them with others. Dropbox provides a free 2GB (with some more to obtain when referring others) to host your files.

Files are synced, you can work offline, you can have a local folder on your computer (Windows, OSX, Linux) or on one of your devices (Android, iOS etc...).


Just do what you usually do: open and edit files and save them. But rest assured that you will be able to access them on another device as well.

For me, it replaces to a large extent other means of sharing (e.g. ftp) or sending large files (e.g. YouSendit). And when installed as an app, compared to the web-interface, you get notifications for updates and an additional bonus space.

Evernote
http://www.evernote.com/

At my latest conference, someone pointed me to Evernote. This is a note-taking application, where you can start taking notes. By tagging them and organizing them into notebooks, you can structure them at will. E.g. I have personal projects, research, teaching and general computing notebooks, where I edit stuff. You can even add audio or webcam notes alongside HTML-based text-nodes. Images can be included as well and there are some helper tools to snap websites or part thereof.

It also integrated with a wide variety of other tools, so you can e.g. take and annotate a screenshot inside Skitch and have it added to Evernote as well.



Works on almost any device and also through a browser.

I would like to also have an integrated mindmapper (e.g. such as Freemind) and also a simple vectorial drawing tool supporting links (e.g. VUE) so all my note-taking can be merged and synced.

Skitch
http://skitch.com

This is a free Mac screenshot application, but nicely done: it integrates well, includes annotation with ease and also allows easy dragging of any screenshot to an image file or share online with Skitch or to Evernote (they are part of Evernote now).

Now available in the Mac App Store, but also on Android and (soon) iOS.

I've used it for all screenshots on this blog post.

Mendeley Desktop
http://www.mendeley.com/

This is a bibliography organizer for scientists. You can use it to collect, tag and annotate PDFs of publications (articles, books, conference proceedings). It will be synced online and can be used to share publications as well.

There are some lookup features e.g. retrieve from the title using Google Scholar (hit-and-miss) or from the doi-code.

It also integrates with Word or OpenOffice to insert citations and a bibliography and several reference-styles are supported.

While you can use it for non-PDF based documents, this is somehow less convenient. I've started from the BibTex file from my PhD, to insert most of the references I collected and also pointed to a folder where I store most Articles and digital copies of proceedings. That said, it'll take a while to properly organize, tag and correct the entries, but the software is quite helpful.

Not sure why it is free, as the similarly oriented EndNote is not. It is a good alternative. And works on Windows, Linux and OSX and there are iOS versions too to access your references on location. You also receive 1 GB of webspace (500 MB personal and 500 MB for sharing), but more space is not free.



I've had it crash occasionally on certain PDF files, but no harm was done. And sometimes the automatic lookups give false results, but you have to be quite attentive to correctness anyway. Good thing: automatic imports are classified as "to review" and you have to explicitly mark them as "correct" before they are included in the regular database.

Revit: Project Spark – quick overview

$
0
0

Revit: Project Spark – quick overview: So what is Project Spark? Essentially Spark, is a cut down version of Revit, a sort of Revit LT or beginner’s version. Some probably though...
I was hoping to talk a bit about Project Spark, but found the review in the autodesk-revit blog to be complete and quite detailed, so I advice to read it there first (and then come back to comment if you want).

Autodesk is quite active in providing new Lab projects and also launched several new products recently in the Mac App Store and in the iTunes App Store (for iOS devices).

This product is a free, limited version, based on Revit 2012. It provides a subset of what you can do inside Revit, while having enough limitations that it won't interfere with license sales of Revit.

  • You can use it for modeling, but not for rendering or analysis.
    • FBX export does allow you to link it to external rendering software
    • DWG import/export is also good to have. Could it replace AutoCAD in some offices?
  • No massing nor in-place families, nor view filters or grouping could pose problems for more advanced usage. The other limitations seem fair.
    • There is Family editing, however, so you can do quite advanced Revit-stuff.
  • And you can not use it to freely add some Revit seats to your company as Spark-files will not open in Revit. You can however load Revit files as a reference. That said, it can be a nice tool for other people in the design team.

I wonder if you could somehow combine it with Project Vasari, which is also free and also based on Revit, but which provides analysis tools.

And, as always, only on Windows.

PythonOCC : Open Source interactive CAD shell (and how to run it on OSX)

$
0
0
What is PythonOCC?

PythonOCC is an Open Source (LGPL) Python-wrapper for OpenCASCADE.

So what is OpenCASCADE (OCC)?

This is an advanced Open Source (custom license) modeling kernel, comparable to commercial engines, such as ACIS or Parasolid, which are used in quite some commercial CAD programs. When you want to develop CAD software, you could use OCC and write programs in C++.

And why using Python?

With this wrapper, you can create CAD and geometry scripts in Python, which is an interpreted Object-oriented scripting language. You can write almost "on-the-fly" and seriously reduce the implementation effort, by skipping the compiling-phase. You can even interact with a running program in the Python interpreter.
Want to read more about this?
So far so good. Now the nasty, technical stuff... I want to have it running on my Macbook Pro. Don't even attempt to do this if you lack the Developer extensions (XCode needs to be installed and X11, which provides most of what you need). I'm using Snow Leopard (OSX 10.6.8) and XCode 3.2.6, which are not the latest versions, now Lion has been released.
The rest of this post is quite detailed, but I'm putting this out for others to comment on and learn from. It is quite a long story, sadly. Not a download, install, accept EULA and run type of software installation.
1. Install OpenCASCADE through OCE

While OpenCASCADE and Python are both cross-platform, OpenCASCADE is not natively supported on OSX. There is a team of volunteers that have done a tremendous effort to get OpenCASCADE re-organized and more tweaked for current compilers and platforms. This is the OpenCASCADE Community Edition (Google OCE-dev Group and Github OCE source Repsitory).

So I downloaded the binary installer from Github for OSX, currently at release "OCE 0.6.0". This will be installed in /Library/OCE/0.6.0 although the installer doesn't inform you about this!

Then you have to ensure the X11.app is available (the XWindowing system, which is quite alien from the native Aqua interface from OSX).

xterm > terminal program in X11
If all goes well, you can test to see if OpenCASCADE (in the OCE version) is properly installed when you can launch DRAWEXE, a graphical, command-line utility to interact with OCE, which is available in the bin folder. There is a menu-window and a prompt in the terminal. This is old school ;)

Then you can follow the DRAWEXE-example from the OpenCASCADE website.


Beware, I've had to manage a few things to get this far:
  • Install Developer tools from Apple (XCode, X11)
  • The binary installer for OCE is precompiled for OSX Snow Leopard (10.6) in 64-bit. If you use a different platform, you should probably compile from sources. This is made easier with the OCE distribution.
  • I've had to install 'ftgl', which is the OpenGL Font Rendering Library. To be able to use that, I had to go to the downloaded ftgl compressed archive, unpack it, open Terminal.app and "cd" into the folder and type:
    • ./configure
    • make
    • make install

2. Install PythonOCC from sources

While the PythonOCC team provided binary installers, they are currently outdated, so I started from the most recent source files. The sources are hosted on github and use the git version control system. This is a tool to work on a local copy, with the possibility to update from the github site, create your own local branches, merge them etc... If you don't know what this all means, you can also download a compressed archive if you want.


I've installed git from Macports or fink, IIRC. Fink and Macports are both ways to install typical Linux-applications, similar in approach to the package manager tools found in Linux (e.g. apt-get). This takes care of getting all dependencies included, without destroying your OSX system too much...

Create a folder somewhere, go into it from the Terminal and type:

  • git pull git://github.com/tpaviot/pythonocc.git

PythonOCC comes with two embedded libraries, which are not trivial to install.

Come to think of it, I had to also install the CMake build system from Kitware... This is an Open Source build system, which makes it easier to write makefiles (the text files to tell your compiler how sources are turned into executable programs). This cmake-file can be written platform-independently (up to a certain level) and be used in Linux, Windows, OSX.

  • SMESH is used for advanced control over meshing and tesselation. Since it is quite hard to install and requires a fortran compiler, they are trying to remove it as a separate module to install.
  • GEOM is a parametric framework, based on SalomeGeometry. The sources are included in PythonOCC (/src/contrib/GEOM-5.1.5.9).
    • Before I could compile, I had to comment out a few lines in the CMakeFiles.txt file, which is the input for CMake. That was because the queried environment variables have changed in OCE 0.6.0 and are to a large extent not required anymore. I placed a # sign before some of the lines:
      • #FIND_PATH(OCC_INCLUDE_PATH Standard_Real.hxx $ENV{CASROOT}/inc)
      • #SET(OCC_LIB_PATH "$ENV{CASROOT}/lib")
      • #FIND_LIBRARY(OCC_LIB_PATH TKernel PATHS $ENV{CASROOT}/lib)
      • #MESSAGE(${OCC_LIB_PATH})
    • Then I started compilation, using CMake in the GEOM folder (but build in a sub-folder to not mess up the source folder):
      • mkdir _MyBuild
      • cmake -DOCC_INCLUDE_PATH=/Library/OCE/0.6.0/include/oce -DOCC_LIB_PATH=/Library/OCE/0.6.0/lib ..
      • make
      • make install
    • If all goes well, the GEOM modules are installed on your system. In my case, the libraries arrived in /usr/local/lib/GEOM-5.1.5.9 and the header files in /usr/local/include/GEOM-5.1.5.9
Now PythonOCC itself... Not fully there, yet... by far.
    I went back to the main pythonocc folder, downloaded from github. The process takes two steps:
    • python setup.py build --disable-SMESH --with-occ-include=/Library/OCE/0.6.0/include/oce --with-occ-lib=/Library/OCE/0.6.0/lib --with-geom-lib=/usr/local/lib/GEOM-5.1.5.9
    • python setup.py install --disable-SMESH --with-occ-include=/Library/OCE/0.6.0/include/oce --with-occ-lib=/Library/OCE/0.6.0/lib --with-geom-lib=/usr/local/lib/GEOM-5.1.5.9
    So this is a two-step process: building and installing. If all goes well, you will have an additional OCC folder inside your main site-packages of Python: /Library/Python/2.6/site-packages

    To check that OCC is actually available inside Python, go (again) to the Terminal.app and type:

    • python

    to launch the current default python (the one installed from Apple) and load the OCC libraries:

    • from OCC import *

    This will take a while, but as long as you don't see errors, you are good to go.


    3. Graphical User Interface and windows?

    While you can start writing command-line python-scripts directly, there is a caveat! There is no GUI.

    And while I would like to say that there is an easy, cross-platform solution, alas it is convoluted on OSX.  Last time I tried to install PythonOCC on Windows, all was up and running in maybe 20 minutes: python, OpenCASCADE, PythonOCC, Qt, PyQt4.

    The PythonOCC team have come up with three "backends" for GUI's and one wrapper class around it that frees the user from too much GUI-stuff.
    • wx : a wxWidgets based backed (which is a cross-platform GUI system, for Windows, Linux, OSX).
    • qt : the Nokia Qt frameworks, including GUI stuff, running on most systems (Windows, Linux, OSX, embedded Linux, some smartphones).
    • python-xlib : an XWindow based simpler layer.
    For OSX, the wx option is, well, broken. Don't attempt it, unless you "really" know what you are doing. I'm not. I tried in the past and gave up. It is a mixture of X11, OSX and hacking.

    And to use Qt in python, you need a wrapper. There is PyQt from Riverbank software (which has some license limitations) and more recently PySide which has a more liberal license. All instructions point to PyQt so that is what I will use.
    1. If you have installed Qt4 before, beware! On OSX, there are two version: qt4-mac and qt4-x11. The first is native, using Cocoa and the Aqua interface. Really good integration in OSX and very usable. While this is totally recommended for any cross-platform development. However... not for OpenCASCADE, at the moment. So I uninstalled Qt4-mac, alas.
    • sudo /Developer/Tools/uninstall-qt.py
  • Then you need to install the qt4-x11 version, which is far from easy. I used Fink. This is only the bare summary:
    • install fink and update it so it is current:
      • fink selfupdate
      • fink update-all
    • This can take quite a while... and comes with a large amount of software: cmake, python, qt4-mac... However, everything resides in /sw that does not hinder the rest of OSX.
    • Now you are ready to install qt4-x11:
      • fink install qt4-base-x11
    • This comes with a few hundred dependencies and can take quite long (a few hours on my machine). I had to answer a few questions and avoided some "aes" options, as described in my comments on the PythonOCC blog.
    • check that the Fink version of qt4-x11 is installed. Type "qmake -v" into a terminal. It should point to qt4-x11 inside the /sw folder.
  • Before you can use PyQt4, you need to install another library, called sip from Riverbank Software (who also make PyQt4).
    • Download the installer. I've had an API conflict between the precompile PyQt4 form the PythonOCC.org site, so I have to use an older version.
      • SIP-4.12.3 complained:  "RuntimeError: the sip module implements API v8.0 to v8.1 but the PyQt4.QtCore module requires API v7.0"
      • SIP-4.10 worked fine.
        • python configure.py
        • make
        • sudo make install
  • Now you can use the pre-compiled PyQt4 provided on the PythonOCC.org website. There are pre-compiled released for OpenCASCADE and PythonOCC too, but they are for older versions (OCC 6.3.0, while OCE 0.6.0 is using OCC 6.5.1). The number difference is small, but is about two years older.
  • --- EDIT ---- I've had to hack one line in the OCCViewer.py file (installed inside your Python site-packages folder: the first line was included, but gave an error when running a script using the GUI. I've had to replace the modules call with the expected result string:
    • comment out v3d_module_library = sys.modules['_V3d'].__file__
    • replace with v3d_module_library = '/Library/Python/2.6/site-packages/OCC/_V3d.so'
    Finally something that works

    Now some picture of a running system...

    Double-clicked a python script in the PythonOCC Examples/Level1/Geometry folder, called "Geometrydemos.py". X11 should be started and the python script runs inside a Terminal.



    This is an interactive view: you can zoom, pan, orbit, select items and call some commands in the menu. It uses X11 for display (see the X-cross in the window), but other than that, it runs directly inside OSX.

    My personal thought: installing XCode, X11, fink (with hundreds of programs that are already inside OSX), OpenCASCADE, qt4-x11, SIP, PyQt4 and finally PythonOCC to make small scripts is quite a contradiction... But it is open, flexible, cross-platform and can be the basis to prototype a new CAD system that innovates.

    123D apps from Autodesk > Create, Make and Play

    $
    0
    0
    Autodesk is hard at work trying to stimulate the creator in all of us. They are re-branding some of their previous applications into a suite of tools aimed at the creator and maker.

    123D Catch : turn images into 3D objects


    Previously known as "Project Photofly" on the Autodesk Labs and discussed in http://cad-3d.blogspot.com/2011/06/project-photofly-20-available-from.html this is a Windows application to turn a series of photographs, taken with a regular digital camera, into a 3D model, automatically. It requires an online connection, as the processing of the images happens on the Autodesk servers.


    Beware: I have installed it in a virtual Windows XP on Parallels, but I had to take care to use a local path (e.g. C:\Temp) to ensure proper uploading. The My Documents folder which was linked to my actual Documents folder in OSX was not usable as such.

    You can export the 3D model in e.g. FBX format for use in other applications.

    123D Make : turn 3D objects into 2D Slices

    This is a new Mac-only application (for now) that turns a 3D model into 2D slices that can be directly printed on a Laser cutter. You load an included model or one of your own and can quite easily create a series of cutout contours that are directly layed out on one or more sheets. While the included templates are US-based (inches, Letter format), you can switch to cm or mm and set your own sheet size (e.g. 600x300mm is what we have available in our local Fablab).

    123D Make (Mac-only)

    Beware that it only runs on Mac OSX (intel CPU) and expires on 31/1/2012!


    The app can import STL files or OBJ files only. For proper smooth objects, both can be used. You can create these in most 3D modeling software.

    The example I tried was a Rhino model, exported into STL. When trying the OBJ format, it did not read the NURBS version and could not properly import the polygon mesh version. STL seemed more reliable.
    Interlocked slices from Rhino STL file
    The end result can be exported into EPS or PDF format, which can be used directly (e.g. to send to the Lasercutter or to edit in Illustrator or Inkscape if needed).

    123D Sculpt : an iPad Sculpting application

    The final app is only available for iPad in the App Store. I could not try this myself, but it seems to be a nice app so definitely check it out if you have an iPad.


    What I don't fully get is what you can do with the results... You can share it online as a movie or on social media sites, but it is unclear if you can get your 3D model into a usable form outside of this app.

    Final Conclusions

    While the apps shown here are interesting and are presented as a suite of tools, you need at least two machine to run them: a Mac, a PC (or at least Windows on your Mac) and an iPad.

    They are all free, but are still partially in beta-version, so there are some smaller issues and problems.

    That said, they are oriented towards a larger audience, who don't necessarily have all the knowledge and experience for full CAD software.

    But as always, with more experience you get better results. So when you use this in combination with e.g. Rhino or AutoCAD or SketchUp, you might have better results in the end.

    2012 will be more mobile and synced

    $
    0
    0
    This is a short post talking about mobile CAD. Posted from my new phone.

    This year I want to take a look at BIM, model viewing and sharing on mobile devices, hopefully on different platforms. So far I'm impressed by BIMx and Magicplan, but there is much more.

    Additional content for your BIM software

    $
    0
    0
    While most BIM applications present the user with a fairly large collection of objects (furniture, building elements, drawing details), they don't have everything. Although you can create your own symbols, library objects or families in the software, this is beyond the reach of the average user.

    This is where content libraries step in. While there have been CAD-drawings available for many manufacturers since quite some time, they are usually DWG or DXF drawings in 2D and do not integrate as well in a BIM software as actual library content.

    BIMstop is an example of a recent content library, that provides objects in multiple formats.

    BIMstop presents the users with freely downloadable objects
    in ArchiCAD, Revit, SketchUp and VectorWorks formats

    http://www.bimstop.com

    The following links are some of the pages of the software manufacturers for content libraries. Not all of it is free and the quality may vary, but it can be cheaper to buy a library than to develop objects from scratch. That said, a custom and optimized object that you make for your own context, might be all you need.

    For ArchiCAD specific content (in GDL), check ArchiCAD Wiki: http://www.archicadwiki.com/LinkCollection/GDLObjectDownloads

    For Revit specific content (families), try Autodesk Seek:
    http://seek.autodesk.com

    For VectorWorks specific content (symbols):
    http://www.vectorworks.net/architect/content-libraries.php

    And for SketchUp (which is far from being a BIM software), there is the Google 3D Warehouse:
    http://sketchup.google.com/3dwarehouse

    Autodesk ForceEffect for iOS : Interactive force diagrams

    $
    0
    0
    Yesterday, I installed a new (and currently free) app from Autodesk onto my iPhone, called Autodesk ForceEffect (check it out in the App Store).

    With this app, you can draw a 2D schematic of beams, nodes and forces. It will allow you to quickly assess the reacting forces into a structure. The examples included with the app also show you that a photograph can be used as an underlay, to sketch on top of them, e.g. to check a structure in the field.
    Gallery showing diagram over photo background
    While the iPhone screen is quite small for my not-too-small fingers, it works quite handy: there are automatic guidelines that constrain the direction and alignment of nodes you draw. You can switch units between metric and imperial and use gestures for scaling (pinch), panning (two finger swipe) and editing (single touch). Moreover, while it is hard to sketch an exact size for a truss, you can fix the length be entering the exact value on the dimension line and this will be enforces, even when you start moving nodes around.
    Draw nodes and forces with your fingers
    Click on a truss, and you get the acting forces (in color, with direction to show pressure or tension).

    You can generate a report, which could be used to help you enter the exact nodes and sizes and forces in a FEA software afterwards, when you want to go a step further.
    Automatic Report
    This is exactly the type of app I would have loved while being an architectural engineering student, quite some years ago. It's intuitive, interactive and free (for the moment?). You'll need an iPhone, iPad or iPod Touch to be able to use the software, but I wouldn't be surprised if they will port it to other devices in the near future as well.

    DAZ 3D gives away their Pro software for free

    $
    0
    0
    In an unusual (or panic?) move, 3D software developer DAZ 3D gives away its three major content creation and rendering software for free for a limited time (29th of February 2012). These are unlimited and complete software applications, which used to be commercial before. All software is available for Windows and OSX.

    Check http://www.daz3d.com


    Which programs are available?

    DAZ Studio Pro 4 (used to be $430)

    This is a program to load, pose, animate and render 3D characters. You can load models (free and non-free content is available). One of the novel features is the "Genesis" character model, which can be adapted parametrically, so a single basic model can be tweaked and reshaped in different variations.

    Character modeling is beyond the reach of the average 3D modeler, so being able to use a dedicated software might make it more feasible.

    What's the catch? Well, most models, accessories, poses and bundles will not be free. E.g. the Victoria 5 bundle is about $150. Just to give you an idea.

    Bryce Pro 7 (used to be $250)

    Bryce has been an original, albeit alternative, program to create mostly fantasy landscapes. It changed ownership a few times, but is still around.

    What's the catch? Additional content, materials, rendering options are not free.

    Hexagon 2.5 (used to be $150)

    This is a modeling application which can be used to create models, sculpt them into finer detail, set up the texturing layout and prepare them for rendering (which has to be done in external software).

    What's the catch? Only till 29/2/2012.

    So this is a good deal, but you have to take advantage of it quite soon.

    Review: Google SketchUp for Game Design

    $
    0
    0
    Disclaimer: I was asked by Packt publishing if I was interested in reviewing this book. I immediately accepted, as such a book would fit within some of the themes we handle in our classroom and many students and architects are interested in discovering the world of realtime interactive architecture. The coupling of SketchUp and Unity3D is quite accessible and can be completely free, if you use the basic licenses. Packt provided a free review copy of the book and if you buy it through the provided link, there is a small commission. But the review is my personal opinion only.

    Book info on the Packt-Publishing website

    Google SketchUp for Game Design is a quite recent book, focusing on delivering a reasonable low-entry into the world of Game Design. When you think about presenting architecture to others, an interactive game-like environment is very compelling. Tied to the ubiquity of SketchUp for quick modeling and the Unity3D Game Engine, you can publish interactive models as standalone applications for Windows and OSX, but also on webpages. With an additional license, you can also publish your model to an iOS device (iPhone, iPad, iPod Touch) or an Android device.

    The book is, like most books I read from Packt, reasonably priced and paper and print quality is good. While some of the earlier books I have, tended to have quiet dark screenshots, this seems to be avoided with this one, which is a sign that they are improving their publishing quality. While I'm not too fond of the quite heavy black title backgrounds and the very beginner-oriented style, this is a nice book to read through. It is well structured, with clear goals and promises of what will be delivered in each chapter. But be warned that this is primarily a Beginner's Guide (which is marked on the cover), so I sometimes felt that it focused quite a bit on a step-by-step approach. For me, personally, this is a bit distracting, especially as I seldom read books behind the screen of my computer. Just too much chance of distraction…

    Review

    The first few chapters present a general outlook on developing (modeling and texturing) "props" or "assets" for a Game. Translated for architects, this usually means modeling objects, buildings and the site that become the environment with all its detail. This is not a book about creating walking animated characters or to develop the scripts for a First Person Shooter or a Massive Multi-player Online Environment. There are other books that explore these topics.
    First warning: this book tends to be a bit naive, but I assume it is deliberate, as to appeal to a beginner audience, that wants to get started but doesn't know how to.

    It does sound a bit too harsh on other books, that are said to be skipping too much steps or tend to promise unrealistic expectations. There is also the claim that game and movies are getting closer together, but I feel that the current game quality is more up the the level of movies of a decade ago. Nice, spectacular, realistic for sure, but the armies of professional Special Effects houses is not standing still either. That said, you can reach a very acceptable graphic quality with reasonable efforts today, even when working alone.
    Second warning: I think the writer has chosen the right content for the book, but maybe not the right title…

    Only at page 55, you will open SketchUp for the first time, to model a wooden pallet. The first three chapters are looking at "other tools" and "other resources" mostly: stock model and texture websites, some utility software and a full chapter on preparing a texture for the wooden pallet we will develop.

    Contrary to the habits of architectural modelers to create complex models with simple colors, game modeling is quite the reverse: creating simple geometry, but heavily relying on textures. This is an important distinction to make when you come from an architectural background. We tend to focus mostly on the building with all its glorious detail, while visualization and game artists focus on the noisy, gritty details through the textures and map this onto the geometry. That said, this is good skill to master, even as an architect, so I advice you to apply it more often in your work. The Photo Match and texturing tools of SketchUp are very adequate and can lead you to very compelling results.
    Third warning: this book tends to present what you need to do step-by-step firstly, and only talks about why you would do so afterwards, whereas I would do it the opposite way.

    But at least, after you made something, there is usually a paragraph that reflects on it, which has good educational values, even when you eventually use other tools and software.
    Fourth warning: while Adobe Photoshop is widely used by artists worldwide, this book explains all texturing work using the GIMP, the Open Source photo manipulation software.

    The end result is quite the same, but architects typically are not used to this software. But my advice is to just follow along in whatever software you prefer. There are quite some interesting workflow tips and techniques explained in this book. One particular example makes a simple colored model that is translated into GIMP, where it serves as flat colors to easy the selection process and the creation of masks. Back in SketchUp, the Sandbox tools are discussed, which I never used before. And then the process of getting your SketchUp model inside the free version of Unity3D is described. They specifically mention how to get models from the free version of SketchUp into Unity, which is more involved by the lack of an FBX-export in the Pro-version. While Unity can read Collada files (*.dae), it gives problems with the free version of SketchUp. Here, it is advised to use the FBX Conversion software from Autodesk, who controls the FBX format. Then it is shown how easy it is to load the model, position it, add colliders, so you don't fall through and than how to add a First Person Controller, which is included with Unity3D, that you can use to walk around freely. If you do this for the very first time, this is very rewarding moment and might be all you need to do when you are mainly interested in game modeling to present your design to others.
    Fifth warning: Architects like to make clean (and even sterile) models, whereas game artists tend to mimic the more realistic, everyday world around is, with all its grime and grit and all the rubbish that is lying around. So they tend to go for a worn-out look. Be warned.
    Almost at the end, and this is very interesting for other use cases too, there is a chapter on how to model a full car, starting from a few blueprints and some pictures. The model is not perfect, but very usable and not too heavy. I do recall how my students often add trees and cars as stock models into their scenes, only to discover that they slow everything down considerably and to discover that they contain more polygons that the actual architectural model they tend to enliven.

    After the car, one chapter will elaborate one building into more detail, but this is simply too simplistic for architects, who would use a completely different approach. But a valuable lesson to learn is that you need to think in volumes rather than in planes.
    Last warning: avoid single planes! In SketchUp, you see front and back faces, but only the front faces become visible in other software (typically rendering applications or, in this case, Unity3D). Avoiding this demands more attention during modeling, but will lead to cleaner and better behaving models, so it is best to stick to this advice. Only for single glass planes and fences, it might be good to export 2-sided faces.
    Appendix A talks about MakeHuman to generate a life-like mesh of a human body and also explains how it can be optimized in Meshlab to limit the amount of polygons, but as it is not used in the rest of the book, I don't see its point here. The character will not be animated (as this would take a whole new book).

    Conclusion

    Overall, this is an interesting book, primarily for a beginner audience, but only half of it is actually working inside SketchUp. But the results you obtain are relevant and are reachable for everybody, which is not always the case in more advanced modeling or visualization books.

    Book info on the Packt-Publishing website 

    Moment of Inspiration > Mac version available for beta testing

    $
    0
    0
    MoI (Moment of Inspiration) has been around for quite some time, as a standalone modeler for Windows. It is developed by the former creator of Rhinoceros 3D and focuses on freeform geometry primarily. The phrase "SketchUp for MCAD" is sometimes heard to describe this software.

    This is a NURBS modeling application, with a particular attention to user interaction and a minimal interface. You can use it mostly using a mouse or even a pen (e.g. from Wacom) and I assume that it would work mostly fine even on a touch screen. Could the OSX version be a hint of a possible future iOS version for iPad? I don't know, but it makes sense and would be really welcomed.

    The interface is mostly icon-based and is not crowded at all (unlike many other CAD applications). The tools are easy to understand (especially when you have been using a program like Rhino before) and there are no commands to type or menu's to step through. There are shortcuts you can use, however, to get more productive.

    Modeling is fairly interactive and everything can be seen fully shaded in the viewports. When you activate a tool, sometimes more tools are visible in an opening sub-panel and the options for the particular tool are displayed above the tools in an additional part of the side pane.

    MoI in action (with some annotations by me)
    All the usual basic commands are available, from extrusions and lofts, to sweeps, revolves, a set of primitive solid objects and Boolean operations. There is also a set of Curve creation tools and especially the sketching of a curve makes sense in this application.

    But it is also a real CAD application, so you can edit curves with their control points, use snapping and coordinates and import/export to other software.

    It's native file format is the same as in Rhino: OpenNURBS (*.3dm), but it can export to IGES, sat, STEP, obj, stl, 3ds, lwo, fbx, SketchUp and even AI (Illustrator) using a projected view. You can read some other formats too:  OpenNURBS, IGES, SAT and STEP and Illustrator files (ai, eps or PDF format). So you can easily integrate this application with other software.

    It is a commercial, closed-source application and the Windows version was about $295, so I expect the OSX version to have the same price, when it is officially released. You can test the beta-version for free and there is a trial for the Windows version available.



    Add iOS and Android license to Unity3D for free

    $
    0
    0
    In a surprising but understandable move, you can temporarily register for a free (basic) license for Unity3D and add the iOS and Android Basic licenses without cost.

    While the Pro version of Unity3D and the additional licenses of the mobile addons are still about $1500 each, the creation of smartphone and tablet apps has finally been more accessible than ever.

    For Android apps you need only the additional Java and Android SDK, but it runs on Windows and OSX. Linux is supported for these SDKs but not Unity3D (yet?).

    For iOS apps (iPad, iPhone and iPod Touch), you need a Mac with OSX and an Intel CPU. While you can prototype a full app and remote control it using your iDevice, you need a non-free iOS developer license, which is $99/year for individual developers.

    What's the catch? This offer is only till 8th of April and the basic versions lack some of the features of the pro versions, but they are very complete and can be used commercially!

    Choose your license (and currency format)...


    Check it out at the Unity3D Store.

    So, what do you plan to develop? I'm looking at getting interactive architectural models from ArchiCAD, passing by Cinema4D and into Unity3D to end up on the iPhone or on a web page.
    $0.00 on the Unity Store receipt page

    Bricsys offering for educational users

    $
    0
    0
    While they still don't have the same popularity as AutoCAD, the Belgian team of Bricsys produces a solid and (mostly) homegrown CAD system: BricsCAD is a DWG-compatible drafting and modeling system, which could replace AutoCAD (LT) in many cases.

    It is a low-cost alternative for accurate technical drafting and 3D modeling.

    They offer their software now for free for educational users, as announced on http://blog.bricsys.com/2012/05/new-bricsys-academic-program.html

    The programming interfaces, allowing you to develop add-ons in a variety of programming languages (Lisp, C++, .NET), should also be available soon. Currently, you can already apply for free access to the developers program. This is quite useful as some developers use this software as the underlying platform for a full CAD solution (add-on and CAD-system) at the price of the add-on.

    BricsCAD runs on Windows and Linux and an OSX version is said to be in preparation.




    ArchiCAD 16 release - some thoughts on ArchiCAD and BIM

    $
    0
    0
    While the "regular" press and websites already talked about ArchiCAD 16 in depth, I want to add a more personal comment here.

    For me, this is the first version since release 8 where I was not involved in any sense during the beta-tests. I was quite active for r8, 8.1, 9, 10, 11 and 12, but due to lack of time could not participate fully for 13, 14 and 15. I'm currently using r15 educational again (for teaching and for an historical reconstruction project - images will come later).

    The core ideas of ArchiCAD are still fine. The long-due updates to some older gripes and limitations are (assumably, I haven't use the software yet) the same as ever. But they provide a quite compelling version with r16.

    However, much of what 16 is about has to be seen in the context of the evolution of ArchiCAD over the previous versions.

    3D Modeling Freedom (from previous versions on)

    3D modeling freedom has taken some big steps over the last few versions (check http://archicadwiki.com/ArchiCAD%20versions for details):
    • First the introduction of Boolean operations (Solid Element Operations) around r8, which were extended in r15 with the connect features;
    • The curtain wall as a "system" tool in r12, which to day is the only one of its kind in ArchiCAD;
    • 3D Document and Partial Structure Display, on the representation side since r12. This is very important, as it allows you to make elaborate drawings from the 3D model, without having to adapt the model itself (e.g. show only load-baring core structure or 3D section views with full construction detail).
    Remake of an older project - check open section in 3D, which is fully linked to the model
    • The Shell tool in ArchiCAD 15 was also significant, as it allows some complex geometry (which was already possible for GDL scripting) directly in the plan and 3D window. In addition, more elaborate modeling freedom through the workplanes is added in the 3D window as well. And don't underestimate the more directly usable complex roofs.
    However, this convinces me that there is a fundamental flaw in ArchiCAD: the "tools" that are provided for modeling, which inherently promising semantic meaning, are mostly geometric: extrusions mostly (walls, slabs, roofs, columns), sweeps (complex wall profile, complex beam and column profile), height-map using the mesh tool and now the shell tool. This is proven by the fact that you need to abuse other tools when the regular tool is not providing the right geometry: e.g. need a sloped slab? use a roof or a mesh. Need a curved roof? use the shell. Need a complex, non-straight stair: place a few slabs and linework.

    ArchiCAD 16

    So what does ArchiCAD 16 really provide as fundamental improvements?

    More design freedom with the MORPH tool. Quite inspired by SketchUp push-pull modeling, which is highly welcomed. In fact, I would really love to use it on the reconstruction project I'm working on right now... But I'll have to wait till september, when they release our local version.

    Info on http://www.graphisoft.com/products/archicad/design.html

    BIM Components: a library in the "cloud" (well, everybody is floating in the cloud these days). But quite fundamental. The GDL concept for parametric library objects is inherently very powerful, despite the fact that nobody else seems to notice and manufacturers still mostly provide DXF 2D details or libraries with thousands of quite similar objects, without any built-in parametricity. Even the ArchiCAD libraries still provide many objects with limited parametrization.

    Info on http://www.graphisoft.com/products/archicad/bimcomponents.html

    Everybody is green and sustainable these days, but the in-built Energy Evaluation can only be praised. Analysis is fundamental in the current evolution towards zero-energy buildings and having the tools directly inside the project development environment is very recommendable. It seems to be an evolved version of the former EcoDesigner add-on and is mostly based on the spatial analysis of the model (using ArchiCAD Zones).

    Considering the complexity of getting ArchiCAD models translated to external analysis software, such as Ecotect, Energy+ or phpp does warrant an integrated solution. I do hope that such addition will convince the majority of our students that BIM is a compelling methodology that belongs at the core of their design studio work and that it no longer makes sense to completely rely on 2D drafting with some addition SketchUp modeling, as many of them do right now.

    Info on http://www.graphisoft.com/products/archicad/green.html

    And finally, they do continue to support and promote IFC, e.g. through the OpenBIM program. I can really recommend them for believing in playing nicely on the collaboration level.

    Info on http://www.graphisoft.com/products/archicad/open.html

    So what is still not so good?

    The Library object interface is still the same old small unusable preview thumbnail, slabs are still only horizontal, there still is only the Curtain wall as a system tool, multi-layer slabs and walls will not resolve in sections and I bet that some of the bugs I discovered in older version are still in place ;)

    But don't let that scare you away. BIM is here to stay and Graphisoft is still one of the leading and forward-thinking developers for this kind of software and they still provide the only one on OSX that is a strong alternative to Revit, although VectorWorks is getting in the same league step-by-step.

    3D scanning using Kinect and free software

    $
    0
    0
    I assume that everybody will at least have heard about the Kinect from Microsoft. It is a mainly a camera that sees depth and color. In addition, it has a whole image interpretation library that is used to detect gestures and poses from people standing in front of it. However, a use that seems more directly applicable to architects and designers is 3D scanning.

    While there are more accurate methods, especially using terrestrial laserscanning that captures millions of points accurately and fast and photogrammetry, that uses plain images, but requires more extensive 3D reconstruction algorithms, the kinect is very attractive, as it is cheap (around $100-150 standalone), is working on "any" computer, partly due to the Open Source drivers that have become available, but also more recently by the Microsoft SDK, although this only works on Windows.

    That said, the majority of architects and designers are not really into coding. Luckily, there are some free and cheap ready-made solutions.

    ReconstructMe

    For Windows, you can try ReconstructMe, which is an all-in-one program, that has a non-commercial version for, well, non-commercial work (e.g. students).

    Skanect

    As an alternative, there is also Skanect, which is available for Windows and OSX. It is not Open Source, but uses several Open Source libraries and is free to use (for now?).

    I connected the Kinect to an USB port, ran the software and all worked out-of-the-box (at least on OSX).

    The interface is basic and rudimentary: you see the depth image, the RGB camera image and a point-cloud 3D view. You set a main accuracy resolution (e.g. 10 mm) and press start. The Kinect starts capturing the points (with added color) and when you move the Kinect around slowly, taking into account that you get enough overlap the measured points are added to the whole scene.

    Scanect with the view on my office (about 860.000 points)
    When you are ready, you can stop and export the results into a PLY file. You can open this e.g. with the Open Source Meshlab or Blender applications, to further edit and export them. The process is fairly simple for the user, but beware that you get huge files. E.g. the scan of the example I show here, is about 420 MB. You also have to take the limited depth into account, so you might have to wander around and carry the laptop with you to get close enough.

    PLY file loaded into MeshLab (some clipping occurs)
    When you have some reference measurements, you can then use this scan as a quite detailed and accurate reference model, although translating this into optimized polygonal meshes or even BIM models is a whole other endeavor.

    Improve usage of BIM during early design phases

    $
    0
    0
    When I was collecting ideas for a book chapter on BIM (that seemed to never have emerged after that), I collected 10 ideas, which I believe still reflect good recommendations to improve the usage of BIM during the early design phases. These ideas are related to BIM software, but you can apply them in any flavor, as long as you can model with Building Elements, Spaces and have control over representation.

    Introduction

    This article gives an overview of several recommendations and tips, to better apply BIM applications and BIM methodologies, in the context of the early design phases. Many of these tips are applicable in any BIM application and they are based on experience gathered from teaching, researching and using BIM software.

    Sometimes they could help software developers to improve the workflow of their particular BIM implementation.

    Tip 1 : Gradually increase the amount of information

    In the early design phases, the architect makes assumptions and lays out the main design intent. There are several different aspects which can assist this process to cope with a gradual increase of detail and information.

    Scale-Sensitive objects allow the design to properly reflect the scale of focus

    The display of a window on a scale 1:100 is necessarily simplified, while the same object, with the same parameters on a scale 1:20 should display more detail, especially with regard to the connection of the frame to its enclosing wall. Most current BIM systems allow this to occur automatically, but when extending the library of “objects” or “families” or “symbols”, it is important to take this into account.

    Start with generic elements

    Walls, floors and roofs can typically be composited from several layers of applied materials, but in the early design phases, this can wrongfully suggest that the design information is more elaborate than it actually is. It is more important to indicate a wall to be an exterior, load-bearing wall and maybe distinguish between a select few project variations, rather than on very specific compositions.

    While not readily available in common software implementations, it is possible to automate the replacement of generic or default elements with specific and more detailed compositions, e.g. through scripting. But currently, this has to be done by either modifying the generic structure or by manually assigning a more specific composition.

    Tip 2 : Make Mass Models and Volume Studies

    Most BIM tools support the Masterplan Scale Level with Mass Modeling tools. And in some cases, there are even automated routines to generate regular building elements from these mass models.

    Unfortunately, this is commonly implemented as a one-way process. It would be good that BIM developers realize that allowing the user to freely migrate between Scale Levels and Design Phases can better support the design process. (FWIW, this was the main topic of my PhD in 2007)

    To some extent, the applications even support this, but not as fully as possible. E.g. we noticed when using this in AutoCAD Architecture, that once you generate the walls and floors from the Mass model, that there was no way back. Modifying the Mass model did not properly reflect on the generated elements.

    Tip 3 : Model with Spaces/Rooms

    Closely related to Mass models are Spaces or Rooms. While most BIM software supports the notion of a Room or Space or Zone object, it is sometimes closer to annotation than to modeling. In e.g. Revit, you can only insert Rooms when the enclosing walls, floors and roofs have been modeled. And while you can model with standalone Zones in ArchiCAD, they only present all their features when the enclosing elements are available and used for Zone generation. This is remarkable, from the point-of-view of the designer, as the room or space is probably one of the most fundamental design entities, directly reflecting how the model proposes a solution for the design program or brief. However, even then it is of utmost importance to use the Room/Zone/Space features to indicate functions and generate listings early on, which can be performed without much effort. Such listing are invaluable for quick program assessment and project cost estimation. And they do form the basis for energy analysis too.

    A good example of this was our usage of building function analysis we performed for a recent study of elderly care centers. Based on 2D PDF and CAD drawings, used as an underlay, we traced the different floor plans using the Zone tool in ArchiCAD, with a custom set of categories. While we attempted to be precise, initially, time constraints enforced a more sloppy and fast approach at peak time for some later cases. However, it did allow us to have a spatial overview of the projects, distinguishing between e.g. circulation, technical rooms, leisure and sanitary rooms, as well as administrative spaces, to be compared between the case studies. In addition, we could present a 3D spatial model, with automatically generated listings alongside. It provided more flexibility, although most of the analysis was still carried out in a spreadsheet.



    A concern we still has was deciding between modeling the net spaces in between the walls or the gross area and volume, up to the outer extents of the facade. Ideally, you'd have both, but you might not want to model both.

    Tip 4 : Don’t import SketchUp models into BIM software

    While most current BIM software supports the import of SKP models and even interprets the faces as actual walls, floors and roofs, it is better not to rely on this functionality. In most cases, the SketchUp model is good “as is”, but not “well-formed”. It is not built up to the accuracy or the structure expected for a correct and manageable BIM model.

    However, if you do insist, don't bother modeling the thickness of walls and roofs in SketchUp. Use it for where it shines most: exterior volume studies. It is however possible to load this model as a reference object, to assist proper remodeling with actual BIM tools, similar as using 2D drawings as underlays.

    Tip 5 : Design on grid and on axis

    In most cases, to have flexible and sound models, it makes sense to ensure that walls, columns and beamse are properly aligned on grids and placed on axis. While not all BIM applications use Grids as actual design entities, those that do allow the user to more properly embed design intent in the model and have clearer indications of connectivity, adjacency and general topology in the building. A good design grid setup will allow faster modeling and allow for a faster design workflow.

    Tip 6 : Model as little as possible...

    While BIM software presents an enormous array of tools and functions, it is wise to adhere to an approach of least effort.
    Model as little as possible, with as few elements as possible in as few files as possible.
    For construction documents and for technical details, it is good to have detail and larger project can benefit of division into several files, but in the early design phase, it is better to try to be efficient.
    • Strive to use the minimal amount of entities and control them with as few parameters as possible.
    • Don’t split elements (e.g. use a full floor and wall and ignore the interconnections at this stage).
    • Adapting the model to design changes is much more flexible and efficient with a smaller set of objects to master.

    Tip 7 : Represent for concept

    While it is tempting to embed photorealism in the design process, it is only a by-product and can often lead to false assumptions. It is advisable to limit some aspects of representation, ensuring that all visual output clearly reflects the immaturity of the design.
    • Ignore texturing or fall back on simplified materials;
    • Avoid hatching, especially when the scale would not present this properly;
    • Limit the amount of annotation to basic room tags and some major dimensions (e.g. height levels);
    • Use conceptual colors, clearly indicating function and design intent, rather than materiality;
    • Make all cut elements pure black; don't show wall, slab and roof layers at this stage.

    Tip 8 : Use simple templates

    A good template is the key to productivity. However, it would be naive to assume that a single template should cater for all phases in the design process. It would be good to have a very basic design template, small and without clutter, with a subset of functions and materials.

    Postpone the use of extensive templates to the later phases in the design process. If the user needs to scroll to get through the list of materials, line types, layers, compositions or other settings, then the template is too extensive. Less is more indeed.

    Tip 9 : Use external references and images

    BIM models are often the collection of information from different sources, such as site measurements, images, reference documentation. While all these documents belong in the design, they should be kept outside of the model. If supported by the software, use underlays, external maps and pictures.

    Do not "import" CAD drawings, especially when they can generated additional clutter, such as layers, line types or annotation styles. (However, if your software supports underlays/XRefs, then you can attach the CAD drawing and yet retain your own BIM template structure).

    Tip 10 : Use the right tool for the right job, but keep only one master

    A hybrid usage of applications is quite common. The design can be elaborated in modeling, drafting and BIM software and at the same time in visualization and simulation tools. However, to ensure consistency, maintain a single master model; which is, preferably, the BIM model.

    If necessary, host other parts of the design in the main BIM model, e.g. by inserting or referencing external geometry and keep the original for all design changes. 2D information can also be hosted, as flat drawings or as PDF documents.
    If at all possible, automate the updating of changes or the workflow.
    This is actually very similar to game development, where “assets” (geometry, textures, sounds, animations) can be created in several applications, yet a full pipeline is established to ensure that different people all work on the same project. Updates to these assets are reflected in the authoring environment.

    A good example can be experienced in a visualization process. E.g. you can "link" an ArchiCAD model to Cinema4D for rendering and animation and even link this model to Unity3D, for realtime exploration. Updates to the BIM model reflect in the visualization model and consecutively reflect in the realtime model. The exact same workflow is also supported between Revit, 3ds Max and Unity.

    Another motivation to keep using the BIM model as the master geometry for visualization are the flexible representations. In a pure modeling software, your geometry is "as is" (unless you apply a fully parametric process). But in BIM, this geometry can be regenerated based on different criteria: e.g. layer settings, scale level, building phase, level of detail (e.g. load-bearing only; finishes) and also cutout sections. And you don't have to export the whole model as one single file. When you create complementary views in the BIM software, you can export the model in chunks and then assemble them in the visualization software.

    Conclusion

    While all of these 10 “rules” can only be taken as recommendations and can be disregarded at times, it is our belief that they can assist with a proper application of BIM in the early stages of the design process. These suggestions have been motivated to counter some skepticism regarding BIM, as many people are convinced that BIM should only be utilized when the design is crystallized. This would be unfortunate, as the main advantage of using BIM is the possibility to better inform the designer about the project and its performance (e.g. cost, energy, esthetics) and improving or adapting the project should be done preferably during the early design phases, when this kind of modifications is still possible.

    The next mind map is a more graphical summary of the 10 tips/recommendations...


    Packt Publishing special offer for 1000th book

    $
    0
    0
    I have a few books that were publishing by Packt Publishing. They are specialized in IT books and ebooks and have a wide offering.



    Books I bought handle Drupal, Blender, Unity and SketchUp (for use with Unity) as discussed in an older post.

    If you register on their site before the end of this month, they will present you a nice free offer (not purchase required) to celebrate their 1000th book. 

    The books are priced fair, they are delivered for free and when you combine a paper book with its ebook, you get a good price reduction. All paper books I have where in Black and White and if you are looking for quite graphical software (e.g. Unity) the images sometimes tend to be a bit dark. The ebooks are in full color.

    Many free video tutorials released (in Dutch...)

    $
    0
    0

    Motivation

    I have worked literally day and night on a expanding series of video tutorials. They are made as part of my teaching assignment at KU Leuven and are meant for our students of Architecture Engineering to replace to a large extent that traditional class-room based sessions. Partly out of necessity, as it becomes harder and harder to support large groups of students and partly out of didactic motivation, as the speed with which students learn CAD and 3D software differs widely. For some, it is always too fast in a class setting, so they give up and start entering Facebook or messaging on their cellphone. For others, they are frustrated as they are already ahead of the explanation, exploring other tools.

    The actual tutorials

    So here is the full YouTube page where I'll post all current and future video's in separate playlists.

    stefkeB - all YouTube video playlists

    At the time of writing, there are videos about ArchiCAD (3 series), AutoCAD (2D basics), SketchUp, Cinema4D, Unity and Artlantis.

    Current playlists on Youtube channel
    Comments and suggestions are welcome, as are requests for other tutorials (applications or subjects).


    The plan is to finish a series of ArchiCAD tutorials on collaboration and simulation in the second half of this academic year and also a series on Rhino (probably using Rhino 5.0 and Grasshopper, on Windows). I'm not sure about a series on Revit, as I'm not too experienced yet to start teaching it. I'd like to work on an openBIM series as well, but I have to learn Solibri Model Checker first to get the workflow in place. Preparations are going on as we speak.


    Background information


    I've began to use screen-recording using the excellent Screenflow software for OSX applications and the free Open Source CamStudio (less polished, but very usable) for the applications which only run on Windows (e.g. Grasshopper for Rhino - videos are not yet recorded) or for which a Windows-version is more common (e.g. AutoCAD).

    My old and aging laptop is getting into trouble, as the hard drive gets quickly filled (40 Gb and counting) and interactive 3D applications while recording full-screen video is quite demanding. Any sponsors who have a spare rccent Macbook Pro (or similar)?

    The videos are all in Dutch, which might be a pity for most of you, but I decided to focus on this first, for the first batch of tutorials. I'm still pondering the option of overdubbing in English, but e.g. the ArchiCAD-based BIM tutorials use the Belgian/Dutch template and library, so it might not be so relevant to be translated. On the other hand, many English tutorials already exist for these applications, so this could fill a niche and is directly used by my students.

    I am wondering if English captions would be sufficient, as this is something I can add (over time) to the existing YouTube videos. Full English versions are also possible, but then I have to re-render everything and upload all of them again, which might take a lot more time than subtitling. Not sure. So far I have one request for a translation of the "split-level" video using ArchiCAD.


    Viewing all 67 articles
    Browse latest View live