pp, meant for manufacturing domain):
And from there I also exported to 3ds Max for some quick rendering:
Recently I decided to re-model it with GH (the main structure), just for fun:
Which took 12 hours.
Granted, I didn't take it to the same level of detail (the GH version is missing decking and rear screens), which would probably be a few more hours.
Also, the GH def is messier than what I am used to doing.
Nonetheless, my first curiosity was simply how long it would take to re-do.
It's an odd comparison, but at the end I felt it was an interesting exercise.
Modeling efficiency is not a topic discussed that often here, any comments?…
Added by Santiago Diaz at 11:23pm on February 22, 2011
rtitions." (http://wias-berlin.de/software/index.jsp?id=TetGen&lang=1)
To continue with my wrapping career, TetRhino (or Tetrino) is a .NET wrapper for the well-known and pretty amazing TetGen mesh tetrahedralization program. It provides one new GH component for discretizing or remeshing objects using TetGen. Basic tetrahedralization functionality is exposed with a few different output types that can be controlled. At the moment, the only control for tetrahedra sizes is the minimum ratio, which is controlled by a slider. This is hardcoded to always be above 1.0-1.1, as it is very easy to generate a LOT of data (and crash)...
The libs are divided again into different modules to allow flexibility and fun with or without Rhino and GH, so have fun. All 4 libs should be placed in a folder (maybe called 'tetgen') in your GH libraries folder. Remember to unblock.
Once again, the libs are provided as-is, with no guarantee of support for now, as I use them internally and do not intend to develop this into a shiny, polished plug-in. If there is enough interest, I can tidy up the code-base and upload it somewhere if someone more savvy than me wants to play.
TetgenGH.gha - Grasshopper assembly which adds the 'Tetrahedralize' component to Mesh -> Triangulation.
TetgenRC.dll - RhinoCommon interface to the Tetgen wrapper.
TetgenSharp.dll - dotNET wrapper for Tetgen.
TetgenWrapper.dll - Actual wrapper for Tetgen.
Obviously, credit where credit is due for this excellent and tiny piece of software:
"The development of TetGen is executed at the Weierstrass Institute for Applied Analysis and Stochastics in the research group of Numerical Mathematics and Scientific Computing." See http://wias-berlin.de/software/index.jsp?id=TetGen&lang=1 for more details about TetGen.
To wrap up, some notes about the inputs:
These are the possible integer Flags (F) values and resultant outputs for the GH component:
0 - Output M yields a closed boundary mesh. Useful for simply remeshing your input mesh.
1 - Output M yields a list of tetra meshes.
2 - Output I yields a DataTree of tetra indices, grouped in lists of 4. Output P yields a list of points to which the tetra indices correspond.
3 - Output I yields a DataTree of edge indices, grouped in lists of 2. Output P yields a list of points to which the edge indices correspond. Useful for lots of things, very easy to create lines from this to plug into K2 or something for some ropey FEA (or not so ropey!) ;)
As this component can potentially create a LOT of data, especially with dense meshes, care should be taken with the MinRatio (R) input. This will try to constrain the tetra to be more or less elongated, which also means that the lower this value gets, the more tetra need to be added to satisfy this constraint. Start with very high values and lower them until satisfactory.
Hopefully shouldn't be an issue, but it's possible that you need the 2015 Microsoft C++ Redistributable.
Happy tetrahedralizing...
UPDATE: The tetgen.zip has been updated with some fixes.
UPDATE2: This is now available on Food4Rhino: http://www.food4rhino.com/app/tetrino
…
Added by Tom Svilans at 1:27am on October 24, 2017
hat aren’t completely there. BIM will have to continue to evolve some more if their supporters want to get to realize the promise that still is. I can’t say much about PLM, but I would say that both BIM and PLM should be considered in future developments of GH and Rhino. David has said several times that some GH limitations regarding geometry and data structures (central to interoperability) are actually Rhino limitations. So, I wouldn’t put so much pressure on David for this, or at least I would distribute the pressure also on the core Rhino development team.
Talking about Rhino vs. GH geometry, there is one (1) wish I have: support for extrusion geometry. GH already inputs extrusion elements from Rhino, but they are converted to breps. Is not a bad thing per se. The problem is when you need to bake several breps that make the Rhino file to weight several hundred MB. When these breps are actually prismatic, extrusion-like solids, is a shame that they aren’t stored as Rhino V5’s extrusion geometry in a file of just a couple of MB (I overcame this once with an inelegant RhinoScript that wasn’t good for other people). This was one of RhinoBIM’s main arguments. We can develop a structural model made of I-beams in GH using the Extrude components. We should be able to bake them as extrusions. That would also work for urban models with thousands of prismatic massing buildings (e.g. extruded footprints). Even GH’s boxes are baked as breps! Baking boxes as extrusions could be practical for voxelated or Minecraft-like models.
(2) Collaborative network support. Maybe with worksession handling, or something that aloud project team members to work on a single definition or in external references or something alike. I know there is another Rhino limitation on this, but maybe clusters are already going in that direction?
And maybe on the plug-ins domain:
(3) Remote control panel that could be really “remote”, like from other computer or device. There is an old Android App for that, but is not only a matter of updating. I mean, it would be great to control a slider with the accelerometer of an Android phone, but to have that on an iPhone will require another development team. If GH could support networks, a remote counterpart of a RCP plug-in could be developed as a cross-platform web app. I don’t know if you can access accelerometer functionality through HTML5 already, but for now, asking a client (or an spectator or any stakeholder for that matter) to control your sliders from gestures of his/her own phone would be awesome (maybe Firefly will fill that hole?).
(4) GIS support. GH already imports .shp files. Meerkat can even access the database, but what about writing to shapefiles or generating our own with databases processed/generated in GH?
(5) SketchUp support. Not only starchitects and corporations are using GH in the AEC. There are a lot of small firms, freelancers and students interested. Most of them use SketchUp for 3D modeling (not CATIA, neither Revit). Yes, you can import/export .skp from Rhino, but if GH could support nested block at bake time (also mentioned by others), it could write .skp files with complex relations of blocks (that are called components in SketchUp) and nested groups, going beyond what Rhino can export.
(6) Read/Write other formats. There are some challenges with proprietary formats that are not completely supported by Rhino, but they’re still a lot of open formats that are relevant to the fields of GH users, like stl and ply for 3D-printing. It could be nice to write mesh colors to a ply for 3D-printing a colored prototype based on GH colors. There are others, like IGES, STEP, COLLADA, etc. and 2D, like svg, odg and pdf. Some of them could offer special formatting options like custom data that the format supports but nobody uses just because is impractical to access this from direct modeling environments (but not from visual programming).
--Ernesto…
and...how to bake meaningful assembly/component type of structures for the rest of the tedious work required > you know what I mean > the ugly part of our business > documentation drawings, BOM, tech etc etc etc.
For instance, let's focus to the planar glazing support items: absolutely no need to make them it via any smart app since they are plenty of them around in the market (unless you are I.M.Pei and you do that exceptional Pyramid wonder thing).
But...the goal is...hmm...to create some kind of "smart" (kinda, he he) solution where components (the "baked" ones, so to speak) are structured in such a way that further work (via conventional CAD apps) is easily managed. To speak in Rhino dialect: nested Blocks and/or nested Refs. Like having components in GH that could manage nested Block/Ref stuff (but I guess that you can do it rather easily via VB).
Back to that ugly truss: It's obvious that this is a nested collection of "repetitions" (should I call them iterations?) : meaning that a void top node owns a module truss that owns 2 supportive sub-trusses that are made by some pipes that own connecting items that own the planar glazing items etc etc etc.
With regard the "own" thing: Imagine a CAD file that is simply a container/place holder of some individual entities (called Models). These Models can be "linked" to others (in a nested parent/child relation). Links can be external of internal. They can be either References or Cells or Shared Cells. This the way that Microstation classifies/handles "entities" (a bit primitive, mind, but nobody's perfect - for the real thing see CATIA/NX).
Back to that ugly truss: Obviously this structure (actually the assembly/component combo related with the given solution) has to be transfered into classic 2d extractions (say: plans, elevations, sections et all). This is done why a weird thing called Dynamic Views/live markers in Microstation (you define Clip planes in 3d space that manage 2d extraction content in something called Drawing Model that controls other weird things called Sheet Models, all these live linked etc etc).
To make things more spicy...these 2d extractions can been viewed as master detail directives: from where 1:1 classic details are made (that is: you apply more Dynamic Views and live markers and life goes on - red pepper extra strong Russian vodka is a must when you do that type of work).
This is where Rhino is out of his depth (but to be fair: it's not designed for this type of work) and also this is where Microstation has no competition at least for AEC purposes (but to be fair: it is designed for this type of work).
Of course Autodesk...well expect soon the Gen Comp equivalent for Revit...a fact that complicates things (for Bentley) a bit given the Revit mania in the AEC world.
Moral: intelligence is good but it's only the tip of the iceberg. …
an almost planar tissue (your case) can cause a variety of issues up to the undo able state (metal parts/components grow in size as well for no reason). See forces estimated by FF below.
2. Therefor I strongly suggest to consider Plan B (a) mastermind a secondary "anchor" capability in order to achieve a far more stable system (b) use a mount design that can support this (and comply with the attractor concept of yours). Here's a variable mount custom system (mostly machined AND not cast) that is suitable for the scope (Rhino reads the stp file OK .... but makes a colossally big file - thus I attach here the original).
3. On first sight lot's of things in this system appear "odd". For instance: is it stable? Why these double cables are used? How far can be adjusted? (that's a classic case for feature driven parametric design - not doable with Rhino).
4. This concept (strut axis exported only) is tested in FORMFINDER and some other far more complex membrane apps that I use quite often (not RhinoMembrane). Here's is what FF tells us about:
Observe a different kind of "stress" when this is converted to radial type:
5. If you insert the stp file to the Rhino file provided (exactly as exported from FORMFINDER - no mods of mine of any kind) you'll see what goes where (and why). That way the usage of double cables is rather obvious (and a lot other things - for instance the way that the struts achieve "equilibrium", see the slots in the base mount plate.
6. If this approach is worth considering your definition requires some serious rethinking (far more simpler/manageable with the drawback that the real parts they are "static" they can adjust only as far this particular solution allows them to do - controlling them parametrically is clearly impossible with the current state of R/GH capabilities).`
All in all: this case works because the cables push the anchor points downwards and the struts push them upwards.
more in a while
…
reaky thing consisting from triangulated "modules" (i.e an assembly out of this, this and that) where the exterior edges ARE always under tension (= SS 304/316 cables OR nylon) and the interior ones MAY be under compression ( = steel, aluminum, wood, carbon) OR ... some of them ...may be under tension. Bastardized T trusses deviate a bit from theory ... but who cares? (not me anyway). T trusses have many variants (but as the greatest ever said: Less is More).
2. Large scale T for AEC is the art of pointless since it costs around the GNP of Nigeria. Here's some indicative components from a module of a multi adjustable TX system costing (the module) ~ the price of my Panigale (Google that):
The above is mailed to a friend who has MIT (yes, that MIT: the top dog) on sight ... therefor he needs some appropriate "credentials", he he.
3. The distance that separates the above with the demo TDT node provided is around 666.666 miles - but we don't care: we are after Art not some testimony to vanity.
4. On purpose I've used a smallish ring to give you a clear indication upon the constrain numero uno in truss design: CLASH matters.
5. You'll need:
(a) A decision related with the tensioners (classic Norseman + SS cables or nylon machined thingies?).
(b) A machinist who can do elementary stuff (like the adapters) and can weld this to that (the "ring" for instance). His abilities must be 1 in a scale of 100. If the fella has a computer (not a CRAY) and he knows what 3dPDF is (hmm) ... well ... use that way to communicate with him PRIOR designing anything: He must agree on the parts BEFORE the whole is attempted (as a design in GH or in some other app).
(c) A carpenter with a wood lathe for the obvious. BTW: BEFORE doing any TDT attempt > ask the carpenter about the available wood strut sizes. Against popular belief DO NOT varnish the wood (use exterior alkyd/oil stains from some top maker like the notorious US company PPG).
http://www.ppgpaints.com/products/paints-stains-data-sheets
(d) Good quality cigars (and espresso) plus some classic music (ZZTop, PFloyd, Cure, Stones, U2 etc etc) during the assembly.
(e) Faith to the Dark Side (see my avatar).
May the Force (the dark option) be with you.…
nd then writes some data to a certain range of cells, but currently I am missing the small bit of code to save the file and then close that certain excel workbook. One other thing to note is that I'm writing into another excel file concurrently from another set of VB componenets, which must remain open, so I don't want to save & close that file. - Only the file which I'm writing data to from this VB component needs to be saved & closed. Any help would be appreciated.
Here is the current bit of code:
Rhino.Runtime.HostUtils.DisplayOleAlerts(False)If _write = True Then'Dim val As DoubleDim row As IntegerDim column As IntegerDim Pole As StringDim Angle As DoubleDim cellValue As StringDim rowstart As Integer
Dim xlApp As ObjectxlApp = System.Runtime.InteropServices.Marshal.GetActiveObject("Excel.Application")Dim wb As Object = xlApp.Workbooks.Open("W:\Bay Bridge Aiming\Knuckle Plate Aiming\Re-work_Field-Aim_20m.xlsx")Dim sheet As Object = wb.Worksheets("Factory-Aim")
rowstart = 0
Dorowstart += 1cellValue = sheet.cells(rowstart, 1).valueLoop Until cellValue = ""
row = rowstartcolumn = 1For Each Pole In Pole_IDsheet.Cells(row, column).value = Polerow = row + 1Next
row = rowstartcolumn = 2For Each Angle In KnucklePlt_Anglesheet.Cells(row, column).value = Anglerow = row + 1Next
End IfA = 0
Much thanks,
Joel…
Added by Joel DeBoef at 12:29pm on October 23, 2012
j), runs simulation in Contam and re-imports results back into Grasshopper for visualization and data processing. Contam (developed by NIST) is a multizone indoor air quality and ventilation analysis computer program. It can be used to determine infiltration, exfiltration, and room-to-room airflows in building systems driven by mechanical means, wind pressures acting on the exterior of the building, and buoyancy effects induced by the indoor and outdoor air temperature difference. You can read more about Contam at NIST website: https://www.nist.gov/services-resources/software/contam
Installation
In order to run Pigeon and and correctly re-import the results back into Grasshopper, you need to have installed the following:
1. Contam 3.2 on your C drive. You can downlaod Contam at: http://www.bfrl.nist.gov/IAQanalysis/CONTAM/download.htm
2. SimRead3 in your Contam folder. SimRead3 is a utility provided to enable you to create text files from SIM files. You can downlaod it at: http://www.bfrl.nist.gov/IAQanalysis/docs/simread32.zip. Please extract the content of the SimRead3 zip file into your Contam folder.
We would like to improve the Pigeon plugin, so please let the us know if you notice any mistake in the .prj input file, or if you have any other suggestion about the plugin's usability.
Disclaimer
The authors reserve the right to not be responsible for the performance and results of the plugin. The entire risk as to the quality and performance of the program is with you. Should the program prove defective, you assume the cost of all necessary servicing, repair or correction.
Credits
Pigeon plugin was developed by Rusne Sileryte and Antonio D'Aquilio as spin-off from a research project at TU Delft supervised by Michela Turrin and Eric van den Ham.…
ou mean by 'Activate Direct Rhino Modifying'. Perhaps you could expand?
I like the idea of mixing and matching script and 'direct' modeling. There seems to be a lot of potential platforms for this:
1. Implict History: Is there a way for GH to read the direct modifications (with History activated) and translate this as a component (or cluster of components?)? IH seems to record the UI events and the associated elements. GH would need to write as well as read the IH info, in order to preserve as much flexibility downstream as possible. You mentioned Houdini. H seems to record all 'implicit' or direct mods, done via the CAD mouse-based UI, in its network graph. Maybe, this should be captured in the IH cluster/component mentioned above.
2. RhinoParametrics: RP has done a lot of work to intercept and translate Rhino commands into its version of Implicit History. Seems to be centred on points, which makes sense as so much of the traditional 'dumb' way of inputing CAD info is based on mouse clicks on screen (points) predicated by commands, active locks, workplanes etc.
3. Gumball: Rubberduck's use of the new Gumball tool to capture 'direct' modeling inputs thru the Gumball points to a good source for capturing this kind or input, that is related to the 'macro recorder' approach taken by RP and IH.
4. The new Geom Cache component seems to be able to preserve a lot of info about the baked object. There may be even a way to read tagged info generated both GH baked with the "reference" object, and external to GH (by IH, the gumball or even third party apps like RP).
Would be interesting to know what kind of info is 'preserved'. Houdini seems to have a pretty consistent approach to geometric data, that seems to allow parallel NURBS/subD/mesh versions of the geometry. It also seems to have a coherent heirarchical approach to vertices/edges/loops/faces etc that allows the subelements to be arbitarily grouped for 'direct' modeling, and still be part of a procedural script.
I guess the polygon / mesh approach to geometry lends itself to this. If all the procedural commands/components all understand mesh geometry in either vertex, edge, face format, then combining direct and script modeling is doable in transparent way?
In your example above, the Geo Cache node 'flattens' the object to dumb geometry which is manipulated using Rhino, then used as a Reference object, in the next section of the graph. I guess there is nothing to stop the follow on components reading the precedenting graph for parameters, for additional intelligence?
Does GH 'get' or 'put' parameter data?
…
when you get external events that occur on a different thread, as might well be the case for hardware controls or sensor data.
Here's essentially what happens:
Something expires (part of) a Grasshopper document, and the NewSolution() method is called upon to rectify this. It starts by iterating over all the objects inside the document and whenever it encounters an object which has the 'expired' flag set to true, it will tell it to recompute itself. This object cannot recompute itself unless all the objects it depends on are also 'solved', so it might cause a shock-wave of recomputes across the entire document. Eventually though all the inputs are available and it recomputes itself and then hands control back to the document solver.
The document solver now continues on its quest to find more 'expired' objects. It might find some in which case the above story is repeated, or maybe there was only ever one expired object, or maybe the object we just found caused all other expires objects to solve themselves, leaving nothing to do for the document solver.
When the document solver has iterated over all the objects and determined that none of them are still 'expired', it will place a call to redraw the Grasshopper canvas and the Rhino viewports.
That is what happens during a proper, single-threaded solution. When there's two (or more) threads operating on the same document, all hell breaks loose:
Let's assume the document solver is halfway done with its job of resolving all expired objects. At this point an external event comes in on a different thread, which is handled immediately by some component. This component places a call to ExpireSolution(True), which sets the 'expired' flags of a bunch of components. Some of these components will already have been handled by the solver in the first thread, so even though the solver thinks all is fine and dandy, these components have in fact expired again. Other components might still be expired because the solver hasn't gotten to them yet. Worst case scenario, a component just finished solving itself on the first thread and the data inside of it is being harvested by a downstream component. While it's collecting this data the second thread wipes the data, causing a mismatch and probably a crash.
The Grasshopper core algorithms are not thread-safe and if you start calling methods from different threads, you will run into clashes.
What you need to do is 'invoke' the first thread from your second thread. That way the first thread is allowed to finish what it's doing before getting around to your request. Invoking is a very important concept when you're writing a multi-threaded app with a GUI and there's plenty of online resources explaining how it works. Here's two:
http://weblogs.asp.net/justin_rogers/pages/126345.aspx
http://www.yoda.arachsys.com/csharp/threads/winforms.shtml
--
David Rutten
david@mcneel.com
Poprad, Slovakia…
Added by David Rutten at 4:04am on February 25, 2011