diverse group of design participants from afar for a full schedule of exchanges with leading practitioners, practices, fabrication labs… all while exposed to European transit infrastructure... trains planes & even a few mountain roads. LaN FLIGHT EUROPE marks LaN's fifth initiative on-the-fly & our first in EUROPE. JOIN us for the full trip or the leg that suits your interests. LaN is looking to attract a geographically diverse group of students & professionals with various design backgrounds. LaN FLIGHT 2012 EU is co-piloted by LaN Monika Wittig & Co-de-iT Andrea Graziano. LaN FLIGHT is looking for highly ambitious-adaptable-endurance oriented participants to fully embrace the nature of this curated experience. Please take a look at our 3 previous editions to best judge if this type of experience suits you. If you are willing to allot 8 days of your life to this pursuit and have no allergies to extreme mobility & group dynamics… welcome to LaN FLIGHT.…
mport the geometry again.
Right?
How about this? I add an extra object called something like "Geometry Cache". You have to give it a unique name. If you plug geometry data into the left side of this component, it will bake all that geometry and attach UserStrings to all those objects like "<name>: {0;0;3}(8)" where <name> would be your name and the rest is the exact location of that piece of geometry in a DataTree. It should probably also delete any objects already in the 3dm file that have that custom name/data assigned to them.
If you don't plug any wires into the left side, it will instead search the 3dm file for all geometry with the appropriate user data, load them into a correct DataTree and supply that data to whoever plugs into the right side.
If you plug wires in both ends, it will just function as a generic Geometry Parameter.
It might be tricky to write a good event handler for this thing, maybe I'll just restrict myself to an UPDATE NOW! button on the object itself, so you can trigger an update manually.
ps. benefit of this approach is that everyone can create and harvest geometry with such user text, whether they use Grasshopper or not.
--
David Rutten
david@mcneel.com
Poprad, Slovakia…
me)
And got the same result as you did. Suddenly the definition started working. Although I got this error message when I opened the compression tension null.gh file:
Message log start (chronological): --------------------------------------------------------------------------------Plugin version: 0.8.0066 Input parameter chunk is missing. Archive is corrupt. Output parameter chunk is missing. Archive is corrupt. Output parameter chunk is missing. Archive is corrupt. Output parameter chunk is missing. Archive is corrupt.
Why is that?
Can I dare to ask you few more questions?
2) I want all of my members to be made of solid (not hollow) circular cross-sections.
Does that mean that my diameter and thickness need to have the same values? Like this:
?
3) I have wind load from 8 directions. Is there a way in Karamba to create load groups and choose the one with the most extreme values (group that will be used as the most relevant one for dimensioning)?
Thank you.…
are just the 8 cases, so you're actually doing it right here (scroll down on this page, and you'll see a separate subset all about marching tetrahedrons http://paulbourke.net/geometry/polygonise/). The benefit to using marching tetrahedrons is exactly this: that the number of possible "cuts" through the tetrahedron are dramatically smaller in number than those through a cube.
However, I have found that also what you're seeing that the linear interpolation creates some odd distortions (which is why I went ahead and later did the marching cubes implementation). Some of this comes from the density of the sampling grid: the more dense, the fewer distortions.
What I would suggest, if you want a (relatively) quick way to improve this outcome:
1) build up a full mesh rather that bunch of surfaces, and use Rhinocommon to combine identical vertices, and rebuild the vertex normals
2) run a couple rounds of laplacian smoothing on the mesh to better distribute your vertices (for each vertex, make it equal in location to the average of its neighbours)
3) create a line normal to each vertex roughly the length of your sampling grid and test the endpoints of it against your scalar field formula, and then do one final linear interpolation between those two points for your vertex.
This should give you a smoother mesh for sure.
But good work getting this far! …
Added by David Stasiuk at 1:37am on February 6, 2015
I kept adding new text every day until now... and now I have to change almost all the text I did type but... it's made of curves!
So I was wondering if anyone has ever had similar problems solved by a gh definition
In case no-one has ever had similar troubles (I think you all here are smarter than me :P) how would you proceed to create a similar definition, given all the text has same dimension and font?
I would:
a) create a set with all the possible character-curve in that Font b) create an identical set with the same characters as type
c) compare this set with every given text-curve in the drawing (issue: the number 8 is made of 3 different curve .___. same as letter B... A has 2, as D, R, O, P, p and so on...)
d) list item from set 'b' using pattern I get from 'c'
e) evenctually -this is a moonshot in the moonshot- concatenate characters at 'd' based on proximity of different character-curves (to get "ABC" as a whole text, instead of "A" "B" and "C" as separate instances)
It sounds kind of challenging!
...maybe I'm better start re-writing text NOW as it could EASILY take me a couple of days to get things done... :)…
te and anything you can remove is a benefit (I also find it looks much better, but this is personal taste).
Of course, there are far fewer things going on at the screen on a phone than in a computer. It's very possible this doesn't translate well into an interface for a software like Rhino. I've also had no problems using Windows 8 and a few simple 'metro apps' but these are simple apps that don't compare the complexity of CAD software.
Even Microsoft hasn't gone full metro in the desktop. They did however remove a lot of superfluous shadows, bevels and effects and it looks much better than in Windows 7 in my opinion.
In every new version of Windows I always resented they just added new effects and decorations to the UI without adding much to usability and only slowing down the system. I've found it strange that for the first time that I think they are moving in the right direction Microsoft receives the biggest backlash ever for it. Apparently I have a very heterodox view on good UI and when people were complaining on the superfluous decorations of previous windows installments they didn't really mean it, they just had an axe to grind with the company.…
k and re-do the implementation of system 8 if we decide that we want to add/remove other features. I feel that, right now, there's been such a prioritizing on allowing people to size the HVAC elements in GH and not enough on adding/removing key elements to the system like heat recovery, humidity control, filters on the fan or just allowing people to set a fraction of recirculated air (recirc air only works for system 7 right now). Personally, I feel that most people are going to want the system autosized and we don't need to have component inputs for these. All of these sizing inputs really just distract users from applying the things that they really want to test and they also make a nightmare for software development (this really seems to be the major reason why the implementation of the systems is not finished yet). Rather than focusing on sizing parameters, we should focus on the key elements of the HVAC that people want to add/remove and they can always change the parameters of these elements in the OpenStudio interface.
We can discuss this more when we talk on Thursday. If you want to prepare for it, having a short list of the most important features would be helpful.
-Chris…
RL code inside the panel then the plugin gives a error about a missing internet connection (see the attached picture).
Some details that can give you more perspective about the problem:
-The installation on my PC went exact the same way like i installed it on my laptop (and it works fine on my laptop).
-I use windows 7 on my laptop and windows 8 on my PC.
-Mr. Scott (from McNeel) adviced me to refresh my windows because some connection were broken after a rename of the C drive. But the problem wasn't solved after the refresh.
-Mr. Scott also teamviewed me (before the refresh) and so far i understood everthing looked fine (except the windows error). The Grasshopper also worked fine on his PC.
The Grasshopper setup is also atached in this message. Hopefully someone can help me find a solution. Because my laptop can't run all the resources and my school investigation gets a possible delay.
…
I tell you what I had to do and how I did it.
I have the following situation. A urban context with a square plot 40m x 40m surrounded by buildings.
If I extrude the plot I get 4 surfaces and I need to calculate the minimum daily quantity of direct sunlight hours each test point receives in the period from 22nd of April to 22nd of August. For example for the test point at index 21 of surface with index 1 (I am just creating these numbers in my mind) the minimum is on 27th of April and the test point receive 8 hours (this is also invented for the sake of the example) of direct sunlight. All the other days it receives more. So the values I have to found are these minimums for all the test points. Now how to calculate these minimum quantities is a different issue of the topic of this post and actually I manage it.
Continuing with the explanation of what I had to... so I have only the initial plot that generate 4 surfaces, then I want to test smaller plots generated by an offset of 4 m of the original one, and the relative 4 surfaces for each smaller plot.
So in this case I think I cannot use your suggestion because the object don't exist yet.
I managed creating a loop with Anemone, the loop generate an offset starting from the original at 0 until 4 (then I multiply it by 4 to obtain the offset at 0, 4, 8, 12 and 16. Then I did like you also suggest I record every time the result with the DataRecorder and I create for each result a different branch with the index coming from the loop (0, 1, 2, 3 and 4) with the Flatten component.
In this image you can see all the surfaces saved in the same way as described above and in white the test points that receive minmum or equal than 2.5 hours per day of direct sunlight in the period from from 22nd of April to 22nd of August and in dark gray the test points that receive less.
The main point of this discussion is just the fact that instead use this tricky way I used, or the one you suggest, to analyze separately (because they shade each other) 20 geometries (in this case 20 they could be many more) it would be good if it would be possible just to input all the geometries at the same time and they would not shade each other so to get directly all the results with one run and in a more simple way.
Francesco
…
is set up to manipulate strings into an STL file that is quite different from how Grasshopper defines meshes, in that an STL seems to define each face by XYZ points, Grasshopper wants a single list of all vertex points and then has an allied lists of topological connectivity according to vertex number, so for now I just hacked it to spit out points minus so many duplicates it generates for STL:
Right now it has an internal 3D trigonometric function I added input sliders to control, that creates surfaces that look a lot like molecular orbitals.
So how do I make a mesh? I failed to make a single mesh face from each STL face since AddMesh seems to want a list, so I tried making a single list and matching it with a simple ((1,2,3),(4,5,6),(7,8,9)...) array of connectivity but it hasn't worked yet since the STL list of vertices has duplicates that won't work for Grasshopper and removing the duplicates scrambles the connectivity relation.
After some work on this and seeing the output, I figure I could just randomly populate the mathematical function with points instead, unless it really gives a better mesh result than other routines. I'm not sure what to do with it yet, even if I get the mesh figured out.
import rhinoscriptsyntaximport RhinoPOINTS_CONTAINER =[]POINTS = []class Vector: # struct XYZ def __init__(self,x,y,z): self.x=x self.y=y self.z=z def __str__(self): return str(self.x)+" "+str(self.y)+" "+str(self.z) class Gridcell: # struct GRIDCELL def __init__(self,p,n,val): self.p = p # p=[8] self.n = n # n=[8] self.val = val # val=[8] class Triangle: # struct TRIANGLE def __init__(self,p1,p2,p3): self.p = [p1, p2, p3] # vertices # HACK TO GRAB VERTICES FOR PYTHON OUTPUT POINTS_CONTAINER.append( (p1.x,p1.y,p1.z) ) POINTS_CONTAINER.append( (p2.x,p2.y,p2.z) ) POINTS_CONTAINER.append( (p3.x,p3.y,p3.z) )# return a 3d list of values def readdata(f=lambda x,y,z:x*x+y*y+z*z,size=5.0,steps=11): m=int(steps/2) ki = [] for i in range(steps): kj = [] for j in range(steps): kd=[] for k in range(steps): kd.append(f(size*(i-m)/m,size*(j-m)/m,size*(k-m)/m)) kj.append(kd) ki.append(kj) return ki from math import sin,cos,exp,atan2 def lobes(x,y,z): try: theta = atan2(x,y) # sin t = o except: theta = 0 try: phi = atan2(z,y) except: phi = 0 r = x*x+y*y+z*z ct=cos(PARAMETER_A * theta) cp=cos(PARAMETER_B * phi) return ct*ct*cp*cp*exp(-r/10) def main(): data = readdata(lobes,10,40) isolevel = 0.1 #print(data) triangles=[] for i in range(len(data)-1): for j in range(len(data[i])-1): for k in range(len(data[i][j])-1): p=[None]*8 val=[None]*8 #print(i,j,k) p[0]=Vector(i,j,k) val[0] = data[i][j][k] p[1]=Vector(i+1,j,k) val[1] = data[i+1][j][k] p[2]=Vector(i+1,j+1,k) val[2] = data[i+1][j+1][k] p[3]=Vector(i,j+1,k) val[3] = data[i][j+1][k] p[4]=Vector(i,j,k+1) val[4] = data[i][j][k+1] p[5]=Vector(i+1,j,k+1) val[5] = data[i+1][j][k+1] p[6]=Vector(i+1,j+1,k+1) val[6] = data[i+1][j+1][k+1] p[7]=Vector(i,j+1,k+1) val[7] = data[i][j+1][k+1] grid=Gridcell(p,[],val) triangles.extend(PolygoniseTri(grid,isolevel,0,2,3,7)) triangles.extend(PolygoniseTri(grid,isolevel,0,2,6,7)) triangles.extend(PolygoniseTri(grid,isolevel,0,4,6,7)) triangles.extend(PolygoniseTri(grid,isolevel,0,6,1,2)) triangles.extend(PolygoniseTri(grid,isolevel,0,6,1,4)) triangles.extend(PolygoniseTri(grid,isolevel,5,6,1,4)) def t000F(g, iso, v0, v1, v2, v3): return [] def t0E01(g, iso, v0, v1, v2, v3): return [Triangle( VertexInterp(iso,g.p[v0],g.p[v1],g.val[v0],g.val[v1]), VertexInterp(iso,g.p[v0],g.p[v2],g.val[v0],g.val[v2]), VertexInterp(iso,g.p[v0],g.p[v3],g.val[v0],g.val[v3])) ] def t0D02(g, iso, v0, v1, v2, v3): return [Triangle( VertexInterp(iso,g.p[v1],g.p[v0],g.val[v1],g.val[v0]), VertexInterp(iso,g.p[v1],g.p[v3],g.val[v1],g.val[v3]), VertexInterp(iso,g.p[v1],g.p[v2],g.val[v1],g.val[v2])) ] def t0C03(g, iso, v0, v1, v2, v3): tri=Triangle( VertexInterp(iso,g.p[v0],g.p[v3],g.val[v0],g.val[v3]), VertexInterp(iso,g.p[v0],g.p[v2],g.val[v0],g.val[v2]), VertexInterp(iso,g.p[v1],g.p[v3],g.val[v1],g.val[v3])) return [tri,Triangle( tri.p[2], VertexInterp(iso,g.p[v1],g.p[v2],g.val[v1],g.val[v2]), tri.p[1]) ] def t0B04(g, iso, v0, v1, v2, v3): return [Triangle( VertexInterp(iso,g.p[v2],g.p[v0],g.val[v2],g.val[v0]), VertexInterp(iso,g.p[v2],g.p[v1],g.val[v2],g.val[v1]), VertexInterp(iso,g.p[v2],g.p[v3],g.val[v2],g.val[v3])) ] def t0A05(g, iso, v0, v1, v2, v3): tri = Triangle( VertexInterp(iso,g.p[v0],g.p[v1],g.val[v0],g.val[v1]), VertexInterp(iso,g.p[v2],g.p[v3],g.val[v2],g.val[v3]), VertexInterp(iso,g.p[v0],g.p[v3],g.val[v0],g.val[v3])) return [tri,Triangle( tri.p[0], VertexInterp(iso,g.p[v1],g.p[v2],g.val[v1],g.val[v2]), tri.p[1]) ] def t0906(g, iso, v0, v1, v2, v3): tri=Triangle( VertexInterp(iso,g.p[v0],g.p[v1],g.val[v0],g.val[v1]), VertexInterp(iso,g.p[v1],g.p[v3],g.val[v1],g.val[v3]), VertexInterp(iso,g.p[v2],g.p[v3],g.val[v2],g.val[v3])) return [tri, Triangle( tri.p[0], VertexInterp(iso,g.p[v0],g.p[v2],g.val[v0],g.val[v2]), tri.p[2]) ] def t0708(g, iso, v0, v1, v2, v3): return [Triangle( VertexInterp(iso,g.p[v3],g.p[v0],g.val[v3],g.val[v0]), VertexInterp(iso,g.p[v3],g.p[v2],g.val[v3],g.val[v2]), VertexInterp(iso,g.p[v3],g.p[v1],g.val[v3],g.val[v1])) ] trianglefs = {7:t0708,8:t0708,9:t0906,6:t0906,10:t0A05,5:t0A05,11:t0B04,4:t0B04,12:t0C03,3:t0C03,13:t0D02,2:t0D02,14:t0E01,1:t0E01,0:t000F,15:t000F} def PolygoniseTri(g, iso, v0, v1, v2, v3): triangles = [] # Determine which of the 16 cases we have given which vertices # are above or below the isosurface triindex = 0; if g.val[v0] < iso: triindex |= 1 if g.val[v1] < iso: triindex |= 2 if g.val[v2] < iso: triindex |= 4 if g.val[v3] < iso: triindex |= 8 return trianglefs[triindex](g, iso, v0, v1, v2, v3) def VertexInterp(isolevel,p1,p2,valp1,valp2): if abs(isolevel-valp1) < 0.00001 : return(p1); if abs(isolevel-valp2) < 0.00001 : return(p2); if abs(valp1-valp2) < 0.00001 : return(p1); mu = (isolevel - valp1) / (valp2 - valp1) return Vector(p1.x + mu * (p2.x - p1.x), p1.y + mu * (p2.y - p1.y), p1.z + mu * (p2.z - p1.z)) if __name__ == "__main__": main() # GRASSHOPPER PYTHON OUTPUTPOINTS = rhinoscriptsyntax.AddPoints(POINTS_CONTAINER)POINTS = rhinoscriptsyntax.CullDuplicatePoints(POINTS)…