ies a step further towards informative models, how to extract data through a parametric process and design analysis which leads to performance based schema.The workshop will cover some advanced modeling techniques in grasshopper along with some useful grasshopper plugins "GECO,WEAVERBIRD,KANGAROO and more". An introductory to ecotect analysis will also be inculded.The workshop is dedicated to intermediate Grasshopper users " knowledge of GRASSHOPPER equivalent to which gained in Parametricisim WS or higher is preferred".Knowledge of ECOTECT is a plus but not necessary".
Schedule :Deadline for Registration : May 13,2013Workshop Starts : Thursday, May 16, 2013 - 5:30 pmThe workshop consists of 10 lectures, Each lecture lasts for 3 hours.3 lectures per week (Sun, Tues & Thur) ---------------------------------------------------Fees : 600 L.EYou have to fill the Registration Form below for place reservation.We only have few places available. ---------------------------------------------------Prerequisite :-Students should bring their own laptops---------------------------------------------------Registration Form:https://docs.google.com/forms/d/1qd7cTRi8fGJ3OiVPjiNzHA0ZRmXI2qCvk1CUQ-X_4H8/viewformYou can view previous Parametric workshops,Student work & presnetation here :Previous workshophttps://www.facebook.com/events/469048376477647/https://www.facebook.com/media/set/?set=a.548388031851299.1073741826.470747186282051&type=1https://www.facebook.com/events/178326265647678/…
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)…
lysis, and large-scale prototyping techniques. The research generated at Summer DLAB has been published in international media and peer-reviewed conference papers.
AA Summer DLAB investigates on the correlations between form, material, and structure through the rigorous implementation of computational methods for design, analysis, and fabrication, coupled with analog modes of physical experimentation. Each cycle of the programme devises custom-made architectural processes through the creation of novel associations between conventional and contemporary design and fabrication techniques. The research culminates in the design and fabrication of a one-to-one scale prototype realized by robotic fabrication techniques.
Prominent Features of the programme:
Teaching team: Summer DLAB tutors are selected from recent graduates / current tutors at the AA and the small student ratio (5:1) allows for personalized tutorials and debates.
Facilities: AA Digital Prototyping Lab (DPL) offers laser cutting, CNC milling, and 3d printing facilities, and 2 KUKA robotic arms.
Computational skills: The toolset of Summer DLAB includes but is not limited to Rhinoceros, Grasshopper and various computational analysis tools.
Theoretical understanding: The dissemination of fundamental design techniques and relevant critical thinking methodologies through theoretical sessions and seminars forms one of the major goals of Summer DLAB.
Professional awareness: Participants ranging from 2nd year students to PhD candidates and full-time professionals experience a highly-focused collaborative educational model which promotes research-based design and making.
Robotic Fabrication: Scaled working models are produced via advanced digital machining tools each year, followed by the fabrication of 1:1 scale prototypes with the use of KUKA KR60 and KR30 robots.
Lecture series: Taking advantage of its unique location, London, Summer DLAB creates a vibrant atmosphere with its intense lecture programme.
Eligibility: The workshop is open to architecture and design students and professionals worldwide.
Accreditation: Participants gain 1 Year AA Visiting Membership and are awarded AA Certificate of Attendance at the successful completion of AA Summer DLAB.
Applications: The AA Visiting School requires a fee of £1950 per participant, which includes a £60 Visiting Membership fee. Discount options for groups are available. Please contact the AA Visiting School Coordinator for more details.
The deadline for applications is 16 July 2018. No portfolio or CV, only requirement is the online application form and fees. The online application can be reached from:
https://www.aaschool.ac.uk/STUDY/ONLINEAPPLICATION/visitingApplication.php?schoolID=537
For inquiries, please contact:
elif.erdine@aaschool.ac.uk (Programme Head)…
in with the names translated back into paths. It seems to be fairly similar to the way David's upcoming Geometry Cache that Danny mentioned will function.
Now I just have to figure out what to do with your right pinky!
Secondly, in working with trees in general, I have come up with a number of clusters of my own that simplify frequent tasks. In particular many of them are designed to eliminate the use of the Path Mapper, which I find to be a clumsy tool because it has to be updated every time there is a change in the tree structure fed into it.
Maybe you will find some of them useful. I have attached them all in the definition called "Andrew's Tree Utilities"...
1. Match Path - Given two sets of data with N total items, assign the path structure from one list to the other.
2. Assign Paths - Given a flat set of data and a flat list of paths, format the data items into the specified tree structure.
3. Partial Flatten - Equivalent to a Path Mapper from {A;B;C;D} to {A;B;C}, except it takes an integer value for the number of "levels" to eliminate, and works regardless of the input structure. (i.e. could be {A;B;C} or {0;0;0;A;0;0;B;0;C}
4. Flatten one level - same as above, but defaults to a single level of flattening. I use this one in almost every definition I make.
5. Clip Tree - this reduces a "jagged" set of paths ({0;0} and {0;0;0} and {0;1} etc.), such as are produced by many of the intersection components (the intersections that exist get another level of hierarchy where the nulls remain in the original tree structure) to the overlap among the paths. Equivalent to Path Mapping {A;B}->{A;B} and {A;B;C}->{A;B} but works regardless of the input structure.
…
other kind of planes because I need to deal with Display Pipline .
There's a few threads about similar problem( i'm posting them here as a reference)
1. Viewport rectangle
2. TextTag parallel to Viewport
3. Horster method (with timer)
4. Another horster method to get On screen display (also with timer)
5. Discussion how to send Rhino Viewport Cplane to GH
There is a lot of things possible to do using camera frustum plane such as:
- making custom project layout
- Camera-plane sections
- 3d Isovist (example of Francois)
- projections on the frustum plane
I need to output geometry to Grasshopper in order to use a Frustum Plane for dynamic operations like for example: On Screen Display of Text Tags with sections and other views.
…
s for input and the result will be always in SI! There is an internal conversion from Model Units to Meters. [Warning: I developed and tested the 'bug only in meters and I haven't tested it [intensively] for other units. I recommend you to use meters for now.]
2. Correct! If you input a mesh the component will use the initial mesh as the test grid else it will be meshed based on the gridSize which you won't have full control...
3. Correct! That's how you can minimize the time of the study to zero not calculating what you don't need to know! :)
4. Correct! [and that's why the direction of the normal of the surfaces does matter. It should face outward.]
5. You can do that but then the accuracy of the result could be questionable in some cases. As djordje said center points are the test points and probably you don't want all the glazing to be evaluated based on one single point in case the glass is partially shaded. I understand why are you doing that though and I will add the option to average the result for each test surface similar to what I show in this video 22:27 (http://www.youtube.com/watch?v=aoMy4O3vN6g), so you can subdivide the test surface and then get the average results for the surface.
Best,
Mostapha the gentle! ;)…
1. Buy some anti gravity tissue (available on request by Fotiadis ACME Industries: any color you want, payment in advance, cash only).
2. Create a pavement with a rectangular hole. Use Buchtal Bosco tiles (the most expensive stuff around > we live once). Avoid trees (it's too late) and/or anything (Less is more).
http://www.agrob-buchtal.de/en/cd/produkte/produkte_seiten_2_19881.html?pe_id=88
3 .Put Vodka into the hole (I do hope Russian top stuff).
4. Do a semi submerged grid of tissues (vertical due to 1 - or your money back).
4. Provide armchairs to the spectators (these things take time). Put ZZTop on the stereo (or Cure). Empty your mind. Reset.
5. Wait for some appropriate wind and/or the 4 horsemen (whatever comes first).
Moral: ResetNowForEver…
ine (to greatness):
1. If I was you I'll use boundaries derived from offsetting inwards the inner/outer terrain loops where distance = top cone radius + something (better safe than sorry).
2. That way the "perimeter" chopped cones would be intact cones.
3. Additionally I would use the C# provided in some previous def that does controlled random points (no point with a min distance to any other > a given value [in plain English: top cone radius + something]) and avoid the intersection part as well. This speeds up the whole process and makes it far more logical with regard the structural approach: there's no reason to use "columns" that "overlap".
4. I'll provide a virus placement C# that works with DataTrees of points instead of making them internally using a BrepFace (that's the easiest of things). That way you can control the points properly and use the C# once (as an option) ONLY for putting viruses around using any branch you want.
5. "Columns"/cones derived from, say, 2 separate def sectors (why?) MUST been handled within a single DataTree where branch 0 contains the cones related with viruses and branch 1 (or more) contains the others
But what actually has Daniel to do with all these? If you have a vault in mind ... why bother with stupid cones et all? (Daniel does this for you). Provide some sketch related with the final goal. Or you maybe intend to feed K1/2 with stiffer springs (from cones) and less stiff ones (from top) - if so DON'T join the breps. …
I am not knowledgeable about google maps nor google maps api, but from what I read the two components will definitely show a bit different results due to different topography sources.If it is judging by this 2010 article, your Terrain Generator component offers much higher precisions for USA. Precision goes up to a couple of meters, which is amazing!!On the global scale it offers either SRTM 1 or 3 arc-second data or 30 arc-second GLOBE data. Again this is from the mentioned article, I couldn't find this information by searching the Google Maps website.Terrain Generator 2 component always uses SRTM 1 arc-second data from opentopography.org, and it is limited to 60 degrees north and does not have data for Antarctica. It does not come with satellite image either which is another very convenient feature that you have!I couldn't find information about the allowed radius provided by the Google maps api free account. I limited the "radius_" input to 100 000 meters, even though opentopography.org provides more than that (I successfully downloaded 300 000, but Rhino 5 was not able to create a topography on my PC from such a large amount of data).Even though I couldn't compare the results from two components, by looking at your upper example_LB_terrain_generator.gh definition: set the "I" input of "Surface from points" component to True. In this way the surface will be interpolated through points, which is what we want.
Again thank you for the permission, and I look forward seeing those high precision topography that Google maps offers!!…
lues are of any use from a display perspective as some IES files tend to have upwards of a 1000 numbers. That is why the candela values are visualized in the Rhino viewport.
2. Did you check out the (relatively) new Honeybee_IES Project component? It does produce a Bill of Quantity and also allows an export to Excel. I have explained this here: http://www.grasshopper3d.com/xn/detail/2985220:Comment:1474434
3. Eulumdat to IES is an easy fix. I wasn't aware that anybody had tested this using Eulumdat files. I will add this feature when I update the code next time.
4. Can you describe this simulation? The time taken by the simulation itself should not be that long because Radiance ( the calculation engine) has optimization algorithms to tackle multiple sources. My comment about multiple sources had more to do with Rhino than HB itself.
5. What do you mean by material design ? As in textures for surfaces?
Now, with regards to future work, we don't have a road-map of sorts at present as personally I am not quite sure about what might be useful to people who work exclusively with electric lighting. Most of the (vocal) users of Honeybee tend to be interested in Daylighting and that is where our development efforts have centered over the past year. You can read more about it here and here.
If there is some sort of consensus-based opinion from lighting designers on what would be useful we will look into adding new features.…