deform into rhombic dedocahedrons when they reach equilibrium.
http://mathworld.wolfram.com/CubicClosePacking.html
I was trying to model sphere lattice constrained within a boundary box. When inflated, they would not intersect with each other; they would stay in place; and would be malleable just enough to expand and fill in the gaps in between the spheres.
I started off with the help of this thread here(Thanks for those contributed!). As I understood, there was a bug in Kangaroo2. Solver can't handle more than one item plugged in. So I tried to understand David's Stasiuk's Script and adopted it with a few variations, please see gh file attached.
In the first 5 - I've used David Stasiuk's C# component-variable pressure (posted on June 9, 2015 at 12:25am): 'No. 4.5' being the most successful simulation so far(inflation value is kept very low so that they would not intersect);
although I realised I made some math mistake in setting the close packing grid.(could be checked by plugging voronoi3D to see if the area of the rhombic faces are regular)
No. 6-7 I tried with Kangaroo2 components.
After consulting my tutor(Andrei Jipa)'s help, I realised the following changes could be made:
- The definition posted by David on June 8, 2015 at 4:47pm with constant pressure would've worked better.
- Icosahedrons with WbCatmull(Quad divisions) would result in more even load distribution. With wbloop, vertices more concentrated at poles.
- Load in dir Z could be omitted. Andrei has suggested to use lengths(line) in Kangaroo 2 as 'pressure' instead. And I am trying to improve the grid; and maybe try with David's constant pressure definition. I will keep you guys posted of the progress!
I am new to the parametric world, comments/advice very much appreciated! :) Zhini
…
ing results and I think it is based on the assumption of small displacements. That’s why I want to try with LaDeform.
But doing this I met some problems. I tried to experiment it on the small examples that are provided with Karamba:
1.LaDeform in load-controlled behavior
I know Karamba has mainly been created make form-finding and not properly precise calculations, but I’d like to evaluate deformations of my structure under certain loads (load-controlled). It is said to let it in Default value for MaxDisp (-1).
[Rhino view for deflection of the rope]
In this example derived from a Karamba example (Large_Deformation_Rope.gh), the programs shows different ways to get approximately equal max deflection. But, getting into it, I realized Load Multiplier for gravity is different from one model to another (-3.237 for Analyze TH1 and -134 for LaDeform). So what is the interest of the example if the quite similar shape of deflections are not got under the same loadings? (quite different loadings indeed)
Doesn’t it show on the contrary that LaDeform algorithm does not work properly, if you need to change the load multiplier?
The Grasshopper file is shown below.
2.MaxDisp
When I use the model is “max disp”, I command the deformation, but how can I get the value of the virtual force exerted (which I don’t know because it is now imposed)? What is its link with the imposed deflection?
Otherwise I can’t figure how to use it with displacement-controlled loading
3.Iterative process
As it seems impossible to use LaDeform process, I tried to test it by iterations, as you recommend it on the forum, saying that it is equivalent to an iterative Analyze Th1 process.
I tried to reproduce this loading but the result is not very enthusiastic as you can see. The Rhino file shows the progressive loading, with the corresponding Grasshopper files, where I
- disassemble the model,
- get the previous deformed model
- put in another part of the load,
- re-assemble and then calculate it on the previous deformed shape.
Do you have any idea why the answer is not the same ? (LaDeform seem to give like 5 times less for the same loadings) (and even controlling it by displacements the shapes do not fit the principle of the algorithm would let think)
[RhinView for Iterative process]
First step by analyze Th1, and result by LaDeform
4.Analyze Th1 after LaDeform?
Some tutorials of Karamba show that an analysis with Analyze Th1 is sometimes made immediately after a calculation in large deformations. What is its reason? It seems to sometimes change considerably the result. What is the sense of such an operation? Would it mean that LaDeform is not trustworthy?
ð My question is then: is there a way to make the use of LaDeform for other purposes than form-finding affordable and coherent? If I mistake using it, where?
Thank you very much for your help,
…
tura digital en corte Láser, corte CNC, impresión 3d, y modelado paramétrico.
Este tercer taller enseña los fundamentos del modelado paramétrico y algunas bases de manufactura digital.
PERFIL DEL ALUMNO QUE INGRESA:
Diseñador, Arquitecto, Artista con conocimientos de Rhinoceros interesados en comenza a modelar paramétrico con Grasshopper para fabricación digital básica.
PERFIL DEL ALUMNO QUE EGRESA:
El alumno terminará con los conocimientos y criterios para el desarrollo de piezas o proyectos utilizando fabricación digital, mejorando y agilizando los flujos de trabajo, así como los criterios fundamentales del Modelado Paramétrico -Generativo.
Taller de modelado paramétrico con Grasshopper
Interfase
Manejo de Datos
Data Volátil
Data Persistente
Rangos y dominios
Atractores
Listas y Cull
Modelado por Layer Object
Análisis Básicos
Conexión de Curvas
Superficies
Análisis de Superficies
Panelización Básica
Relaciones con Excel
Modelado generativo
Fechas: del 8 de Febrero al 1º de Marzo
Días: Sábado
Horarios: de 10 am a 3 pm
Sesiones: 4 de 5hrs
Duración: 20 horas
Precio: $3,000.00…
Introduction to Grasshopper Videos by David Rutten.
Wondering how to get started with Grasshopper? Look no further. Spend an some time with the creator of Grasshopper, David Rutten, to learn the
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)…
curve or locus] of a segment AB, in English. The set of all the points from which a segment, AB, is seen under a fixed given angle.
When you construct l'arc capable —by using compass— you obviously need to find the centre of this arc. This can be easily done in GH in many ways by using some trigonometry (e.g. see previous —great— solutions). Whole circles instead of arcs provide supplementary isoptics —β-isoptic and (180º-β)-isoptic—. Coherent normals let you work in any plane.
Or you could just construct β-isoptics of AB by using tangent at A (or B). I mean [Arc SED] component.
If you want the true β-isoptic —the set of all the points— you should use {+β, -β} degrees (2 sides; 2 solutions; 2 arcs), but slider in [-180, +180] degrees provides full range of signed solutions. Orthoptic is provided by ±90º. Notice that ±180º isoptic is just AB segment itself, and 0º isoptic should be the segment outside AB —(-∞, A] U [B, +∞)—. [Radians] component is avoidable.
More compact versions can be achieved by using [F3] component. You can choose among different expressions the one you like the most as long as performs counter clockwise rotation of vector AB, by 180-β degrees, around A; or equivalent. [Panel] is totally avoidable.
Solutions in XY plane —projection; z = 0—, no matter A or B, are easy too. Just be sure about the curve you want to find the intersection with —Curve; your wall— being contained in XY plane.
A few self-explanatory examples showing features.
1 & 5 1st ver. (Supplementary isoptics) (ArcCapableTrigNormals_def_Bel.png)
2 & 6 2nd ver. (SED) (ArcCapableSED_def_Bel.png)
3 & 7 3rd ver. (SED + F3) (ArcCapableSEDF3_def_Bel.png)
4 & 8 4th ver. (SED + F3, Projection) (ArcCapableSEDProjInt_def_Bel.png)
If you want to be compact, 7 could be your best choice. If you prefer orientation robustness, 5. Etcetera.
I hope these versions will help you to compact/visualize; let me know any feedback.
Calculate where 2 points [A & B] meet at a specific angle is just find the geometrical locus called arco capaz in Spanish, arc capable in French (l'isoptique d'un segment de droite) or isoptic [curve or locus]
of a segment AB, in English. The set of all the points from which a segment,
AB, is seen under a fixed given angle.…
chitects, Asymptote Architecture, Mario Bellini Architects and others to design the paneling systems.
Get a quick introduction to Rhino and Grasshopper.
Learn how to digitally reconstruction data from 3D scanners and even from regular photographs.
Experience how to print 3D models using state of the art machines.
Grant the opportunity to perform basic energy and performance analysis of your designs.
All this will be provided in a comprehensive 5 days workshop to be taught by international experts in the field as well as local researchers.
Organized by AUC American University in Cairo and GMVS Geometric Modeling and Visulization Center
…
Added by Zaghloul4d at 6:48pm on December 22, 2010
horas.
Los datos al contextualizar la fachada serán:
Vehículos (ISD: input social data)
Personas (ISD: input social data)
Edificaciones contiguas: (UI: urban input)
Sol (Radiación e iluminación): (EFI: energetic flow input)
Creación de energía solar y térmica: (ECI: energetic contribution input)
Objetivos específicos:
Cada asistente generará una fachada contextual a esos 5 inputs.
Entenderá la plataforma de Grasshopper
Comprenderá los conceptos de diseño generativo
Usará los conceptos de programación orientada a objetos (POO)
Generará renders y modelos físicos de la fachada (Fabricación digital)
Costos: $3,250 alumnos $4,180 alumnos de posgrado y profesores $4,830 profesionales
Aulas VI salón 6205, ITESM CEM
Informes: (55)-34449396 mexdf@krfr.org bioarchitecturestudio@gmail.com
Para más información visitanos en:
Fachadas ContextualesWorkshop >Fachadas Contextuales< KRFR|SEEDKRFR|SEED Red Internacional de Investigación OR/gan
http://www.bioarchitecturestudio.wordpress.com
…
esentar Digital Process: Generative Design Technologies Workshop; Taller especializado que se llevara a cabo en 4 de las ciudades mas importantes de la republica mexicana [Puebla] [Mexico DF] [Guadalajara] [Leon] en Enero y Febrero de 2012. http://gendesigntech.wordpress.com/
Enfocado principalmente a arquitectos, diseñadores industriales, diseñadores de interiores, Urbanistas, Artistas digitales, estudiantes y profesionistas afines al diseño; este Workshop tiene como objetivo proporcionar a los participantes los conocimientos y recursos tecnológicos que les permitan desarrollar los elementos de un proyecto desde la concepción hasta su aplicación de manera completa. Apoyándose en un conjunto potente y flexible de plataformas, los participantes aprenderán a generar, analizar y racionalizar morfologías complejas, formas orgánicas libres y algoritmos computacionales avanzados así como a producir visualizaciones fotorealístas aplicables en diversos proyectos de Diseño. A lo largo de 5 dias de intenso trabajo, exploración y retroalimentación los participantes seran guiados en el desarrollo de un flujo de trabajo mas dinamico, que les permitira explotar al maximo el potencial de las herramientas y potencializar sus habilidades, aptitudes y capacidades. Instructores: Leonardo Nuevo Arenas [Complex Geometry] José Eduardo Sánchez [DesignNest] Daniel Camiro/Luis de la Parra [Chido Studio] http://issuu.com/chidostudiodiseno/docs/digprowork Conoce el programa aquí. http://gendesigntech.wordpress.com/program/ Para registrarte por favor visita. http://gendesigntech.wordpress.com/registro
…
s for architectural design, has been heralded as the new paradigm in architecture for the last decade. Digital design techniques coupled with rapid prototyping have permeated architectural education and practice at all levels. But, besides the endless rhetoric and baseless forms, what can these methods actually contribute to the field? What is the scope of their use?
This workshop seeks to answer these questions by investigating surfaces, surface mathematics and manipulations, and using this investigation to introduce students to the issues of design and fabrication of artifacts.
The workshop will thus introduce participants to the basic concepts for design utilizing scripting techniques, through the exploration of the Python language for Rhinoceros. Together with the study of syntax, data types and scripting techniques the focus will be put on the understanding of the digital tools in relation with the common practice and the ways to approach problems a designer might encounter while using them.
Examples of a previous similiar workshop can be found here
Details: Instructors: Marina Konstantatou (University College London), Pierluigi D’Acunto (ETH Zurich), Vincenzo Reale(Zaha Hadid Architects + Architectural Association London), Giancarlo Torpiano (Architectural Association London) *At least two tutors will be present during the workshop Language: English Schedule: 15 – 16 – 17 MAY 2013 // 9.00 – 18.00 Organizers: SMD + LaTiendaDelCAD + PeQuod Venue: McNeel Europe Offices, c/ Roger de Flor 32-34, 08018 Barcelona (map)
Software: Rhinoceros 5 Grasshopper 0.9.0014 Python Component for Grasshopper
Every participant should bring his or her own laptop with the software installed. In the class will be also computers in case any participant could not bring a laptop.
Links to the softwares will be facilitated to participants once they get into the registration process.
Registration: Students* : 395€ (+vat) Professionals: 495€ (+vat)
Early bird promo
Registrations made before 22nd April will get a discount over the price:
Early Bird promo Student* : 295€ (+vat) Early Bird promo Professional: 395€ (+vat)
For registry, please visit la TiendaDelCAD website
* Students will have to proof their status with a student ID
The course will be confirmed as soon as the minimum number of participants is reached, and no later than the 29th April. There will be places for a total of 14 participants.
Venue: McNeel Europe Offices, c/ Roger de Flor 32-34, 08018 Barcelona…