MIGUEL VIDAL Teaching Curriculum en Print

MIGUEL VIDALArchitect

Madrid Shool of ArchitecturePolytechnic University of Madrid

www.frikearq.comwww.michividal.com

[email protected]: miguel.vidal.calvet

Pablo Casals 6

28011 Madrid

SPAIN00 34 678 346 257

architect / teacher // researcher /// generative design

february

2013

7/103/6

11/2223/3031/3637/4445/5253/7273/7879/318

teaching experience

biography

recommendations

collaborations

workshops

shool projectsappendix 1 official documentsappendix 2 manuals

research

lectures

index

Izaskun Chinchilla and Carlos Jiménez CenamorArchitects and Diploma Tutors, M.Arch Unit 22, The Bartlett School of Architecture

Izaskun ChinchillaTeacher and Ph.D. researcher Polytechnic University of MadridPrincipal Izaskun Chinchilla Architects

Carlos Jiménez CenamorPrincipal Casa Leganitos

Professor Don GrayHead of SchoolKent School of ArchitectureUniversity of Kent

Izaskun [email protected]

Carlos Jiménez [email protected]

UCL Faculty of the Built EnvironmentWates House

22 Gordon StreetLondon

25 February 2013

We collaborated with Miguel Vidal in the development of Cosy Parametrics in December 2011, an experimental workshop on digital techniques and its relation with domestic and traditional design and fabrication. We are writing this letter because I hold him in the highest consideration.

Cosy Parametrics was a fi ve day intensive workshop, that took place in Madrid School of Architecture, with First Term, Second Term and End of Degree students from different Spanish universities: Polytechnique University of Madrid, European Universtiy of Madrid and San Pablo-CEU University, and students from the Unit 22 of The Bartlett. The workshop had an intensive course on parametric design techniques as well as a design studio, with assistance for the development of the students projects. All that was combined with talks from relevant Madrid based practices and collectives and ended with a fi nal jury with invited teachers from those universities.

The goal of Cosy Parametrics was to detach parametric techniques from its usual fi guration of socially isolated proposals. The workshop had an speculative intention on diverse digital techniques, of design and fabrication, in order to explore if they can be used to produce designs in which the domestic, warm and delicate can have a place. We dealt with vernacular techniques easily fabricated but cumbersome to represent and we speculated as to wether, besides geometric conditions, it is possible to parametrize programmatic, environmental and economical strategies.

We asked both Miguel and Guillermo, his partner, to teach the intensive course and assist us in the studio. They prepared specifi c examples of modelling vernacular objects and fabrication techniques, which were used in the students designs. As for the studio, he was a valuable help for the students developing their work, under our supervision. He was capable of structuring solutions for each project he assisted, relating geometric, programmatic and constructive conditions.

Miguel proved to have a solid, up-to-date information of the fi eld, a well-structured knowledge and a creative approach to Digital Architecture. His lessons were carefully documented and he showed confi dence in communicating his ideas. He was able to clearly transmit complex and abstract notions and made them easy to understand. The connections he made with diverse topics, from scientifi c and artistic disciplines, enriched his explanations. He showed a huge amount of enthusiasm in what he explained and he was able to pass it on to the students. He always had a collaborative attitude and preserved a pleasant and polite treatment to the students.

As a conclusion, we would fi rmly recommend Miguel for a post in High Education theaching. Should any question arise regarding his academic performance, do not hesitate to contact us.

Yours faithfully,

TO WHOM IT MAY CONCERN


25 February 2013

25 February 2013

Professor Don GrayHead of School

Kent School of Architecture

University of Kent

19 February 2013


I collaborated with Miguel Vidal in the first development in In the air project, assisted to one of

his courses and eventually invited him, and his partner Guillermo Ramírez, to teach several

masterclasses in the universities in which I am teaching, both the European University of

Madrid and the Polytechnic University San Pablo-CEU. I am writing this letter because I hold him

in the highest consideration.

I first met Miguel in 2008 during the data visualization workshop Visualizar’08: Database City at

Medialab Prado Madrid. He was part of an interdisciplinary team that developed the first version

of In the air, a visualization project on atmospheric pollution in cities. In that occasion, we

developed a version for the city of Madrid also had the opportunity to build and test a physical

prototype for facades linked with the software. He overcame his lack of technical knowledge at

that time with hardwork and a lot of enthusiasm, which he was able to transmit to the rest of the

team. He was important for the successful development of the project.

Afterwards, in 2009, I attended his very first course of Generative Design with Grasshopper,

as I was interested in the topic for the Architectural Design practice and teaching and he was one

of the very few designers in approaching and teaching this sort of digital tools at that time in

Spain. Miguel proved to have a solid, up-to-date information of the field, a well-structured

knowledge and a creative approach to Digital Architecture. His lessons were carefully

documented and he showed confidence in communicating his ideas. He was able to clearly

transmit complex and abstract notions and made them easy to understand. The connections he

made with diverse topics,enriched his explanations. He showed a huge amount of enthusiasm in

what he explained and, as a teacher, he was able to pass on that feeling.

From that experience, I was convinced to ask him and his partner to conduct several

masterclasses of technical orientation to postgraduate students in diverse universities in which

I am a professor. Firstly, during the academic years of 2010-2011 and 2011-2012, I relied on him

to teach introductory classes of parametric and discriminative modelling, in the Master of

Advanced Architectural Techniques (MUTAPA) in the European University of Madrid (UEM). I

was in charge of the Advanced Geometry module and I asked them to introduce the students with

the knowledge of programming into geometry modelling. Miguel gave both a theoric introduction

with past and present examples, relating with diverse areas of knowledge, and conducted a

practical example of parametric modelling, environmental analysis and visualization and

optimization of the results. In other sessions, he also helped the students develop their own

designs and prepare them for digital fabrication to test their proposals. Secondly, during the

academic year of 2012-2013, I asked him to assist on a data visualization masterclass in the

Digital Fabrication Degree of the Polytechnic University in San Pablo-CEU University. He

elaborated an example of the use of programming techniques into this topic, with the Processing

programming environment, with an introductory session. The exercise was a energetic power

visualization of a hybrid solar and wind installation. He used this example to teach how to parse

large amounts of data from datasheets, in this case, of an environmental station and, with the

information obtained, make an interactive visualization with the energetic power throughout the

year.

As a conclusion, I would firmly recommend for a post in theaching in Higher Education. Should

any question arise regarding his academic performance, please do not hesitate to contact me.

Yours faithfully,

Nerea Calvillo

Principal C+arquitectos

Phd Visiting Researcher Goldsmiths University

Associate Professor Universidad de Alicante

Associate Professor Universidad Europea de Madrid

Founder In the Air

19 February 2013

Professor Don GrayHead of SchoolKent School of ArchitectureUniversity of Kent

Enrique Azpilicueta Astarloa [email protected]

Department of Construction and Technology Management Madrid School of Architecture (ETSAM) Polytechnic University of Madrid (UPM)

Avenida Juan de Herrera, 4 28040 Madrid SPAIN

Professor Don Gray Head of School Kent School of Architecture University of Kent

27 February 2013 I tutored Miguel Vidal´s Final Project Construction Design. I am writing this letter on his behalf because I hold him in the highest consideration. Miguel´s design building solution was very creative as it combined environmental and energetic issues with adaptability: it allowed subsequent growth. The environmental and energetic analysis on which he based his design, was carried exhaustively and rigorously. Almost every structural and building components was prefabricated, easily transportable and reusable, which helped in the design´s adaptation possibilities. He outline chronogramme of possible designs under the current condition of uncertainty and adapted each building proposal to a different possibility. Miguel proved to have extraordinary sensitiveness for current environmental and socioeconomical topics and managed to organise solid and creative strategies for problematic situations. During this time, I had a fluid communication with him regarding the mentioned topics and I can firmly say that Miguel’s performance under my academic supervision was highly satisfactory. As a conclusion, I would firmly recommend for a post in Higher Education. Should any question arise regarding his academic performance, please do not hesitate to contact me. Yours faithfully,

Enrique Azpilicueta Astarloa Ph. D. Architect Teacher and researcher Polytechnic University of Madrid


27 February 2013

Nick Novelli

[email protected]

CASE - Rensselaer Polytechnic Institute (RPI) with SOM)

110 Eighth Street,

Troy, NY USA 12180

Kyle Steinfeld

[email protected]

College of Environmental Design

University of California, Berkeley

356 Wurster Hall, MC 1800

Berkeley, CA 94720-1800

28 February 2013


Miguel Vidal was a team member selected to join my Authored Sensing workshop cluster at Smart Geometry 2011, which took place in Copenhagen between 28th of March and 2nd of April 2011, bringing together a global community of innovators in the fields of Architecture, Design, and Engineering for collaborative research and experimentation. Smart Geometry: Building the Invisible comprised a four-day intensive workshop, a public conference, a workshop exhibition and a public symposium.

The Authored Sensing cluster hypothesized that data-driven design must be supported by explicitly designed data. We aimed to inject intent and design into the assumed-passive process of data collection, and promote the production of designer-authored datastreams: idiosyncratic observations that would feed into new designs.

From this broad starting point, the team collaboratively proposed to design environmental data in a workplace. The project consisted of a physical prototype, a self-fabricated and transportable kit of bespoke sensors, and software for data collection and visualization. The suite of sensing devices were intended to be one element in a larger matrix that might intuit feelings and other un-quantifiable states via environmental parameters: temperature, pressure, etc. Additionally, these sensors were designed as office furniture so that, besides their monitoring use, they would be functional. Tying together the sensor data, the software would upload that data to the cloud, and offer visualization and interaction. This visualization tool, after a process of learning and calibration, might represent and communicate unquantifiable states in a heuristic way, in real-time, with the user and with the other members of the team as well.

Miguel was an asset in this endeavor, with up-to-date programming skills, and a creative approach to digital tools. His experience programming visualization tools in Processing, and interfacing with electronic devices and sensors through Arduino were particularly relevant, to the extent that he became the de-facto leader of the visualization methods. The ideas he gave and the connections he made with diverse topics enriched our work. Most importantly, in an intensive, four day workshop, his engagement and hard-working attitude were much appreciated, and contributed in no small way the positive group dynamic that developed. He showed a huge amount of enthusiasm that he was able to pass on to the rest of the members of the team. Because of his positive attributes, I would not hesitate to recommend him for a position in Higher Education.

Yours,

Nick Novelli, PhD Candidate, CASE (Rensselaer Polytechnic Institute with SOM), NY, USA.

Kyle Steinfeld, Assistant Professor of Architecture, College of Environmental Design, University of California, Berkeley.

23 February 2013

Miguel [email protected]

RhinoCommon scripting with C# in Grasshopper and Rhino.Python in Grasshopper and Rhino 5.Custom Grasshopper components with Visual Studio.Drawing and image editing applications with Processing.Electronic and sensors programming with Arduino.Interactive interfaces programming with VVVV.Basic Python scripting in Autodesk Maya.Scripting with Javascript for the Adobe Creative Suite.Websites design with XHTML and CSS.

Parametric modelling: Grasshopper (with Kangaroo, Weaverbird, Geco, Elk, Firefly and gHowl).Environmental analysis: Ecotect, Winair.CAD: Rhinoceros, Autocad, 3D Studio MAX.Graphic Design: Photoshop, Illustrator, InDesign, Acrobat.Video editing: Adobe Premiere.Office automation: Microsoft Office and Open Office.

Software

Programming languages

Spanish: mother tongue.English: Certificate of Proficiency in English (University of Cambridge).French: DELF B1 (Centre International d´Études Pédagogiques).German: Mittelstuffen 1 (Goethe Institut).

Languages

199820012002

Voice and public speaking course at the Polytechnic University of Madrid.

Introduction to Physics simulation using Kangaroo in Grasshopper, Studio Mode online course.

ALGOMAD 2010, at the Shool of Arquitecture of El Vallès (Barcelona): Generative Components and Rhinoscript workshops.

Rhinoscript course at the Graphic Department at the School of Architecture of Madrid.

2011

2013

2009

2009

2010

Complementary education

Authorized Rhino Trainer: Rhino Level 1 and Rhino Level 2 courses at McNeel Europe.

July

January

June

April

Work experience

As a teacher

Invited teacher in Cosy Parametrics, an experimental workshop on digital techniques and its relation with domestic and traditional design and fabrication. Directed by Izaskun Chinchilla and Carlos Jimenez, M.Arch. Diploma Tutors Unit 22 at The Bartlett (UCL), with students from The Bartlett, the European University, the S. Pablo-CEU University and the Polytechnic University of Madrid.

Co-organizer and invited teacher of SmartLAB Granada 2013, a workshop on generative tools for creative purposes in design, in collaboration with the University and the Architectural Association of Granada. Responsible for the intensive course Three scales of design with Grasshopper: city (data visualization), building (parametric models) and mechanism (physical systems) and coordinator of fi ve working team projects.

Invited teacher of programming applied to Geometry in the Master of Advanced Architectural Techniques (MUTAPA) in the European University of Madrid (UEM).

Invited teacher of data visualization and interactive interfaces programming with Processing in the Digitial Fabrication Degree at the School of Architecture of the University San Pablo-CEU.

Teacher of Associative and Parametric Design (basic, advanced and scripting levels) to proffessionals and entrepeneurs in the Association of Economical Promotion of Gran Canaria (SPECG) courses, in collaboration with the University of Las Palmas and fi nanced by the European Social Fund.Invited teacher of Parametric Design with Grasshopper in ALGOMAD 2011, seminary on generative methods in Arquitecture and Design at the IE-University.

Co-founder, with Guillermo Ramirez, of Frikearq, a practice oriented to research and teaching of Generative Design techniques. We have organized and collaborated in more than 30 courses and workshops and trained more than 300 people, including graduate and postgraduate students and proffessionals from different backgrounds, mostly Architects but also Engineers, Industrial Designers and CNC machining.

Assistant scholar and teacher in the course Projects of Parametric Architecture (Proyectos de Arquitectura Paramétrica) of the Architectural Projects Department in Madrid School of Architecture, as part of an Innovation Educational Project of the Polytechnique University of Madrid (UPM), in collaboration with both the Department of Applied Mathematics and the Department of Physics and Installations. Ellaboration of new teaching plan for this new course.Assistant scholar in the Juan de Herrera Institute in Madrid School of Architecture’s Department of Urbanism.

Invited teacher of Parametric Modelling in the Master program of the Architectural Projects Department, Master in Advanced Architectural Design Projects in Madrid School of Architecture.

2009 -

2012

January

January

2011

2013

2013

2011

2011

2011

2010

2009

2012 - 2011

December

DecemberApril

June

March

Education and qualifi cations

Architect, School of Architecture, Polytechnic University of Madrid (UPM). Former School Programme Degree , professionally equivalent to a M.Arch.

Smart Geometry 2011: Building the Invisible, at CITA, Copenhagen. Authored sensing cluster, coordinated by Kyle Steinfeld (University of California, Berkeley), Kat Park (SOM) and Nick Novelli (CASE). Design of a prototype to monitorize and visualize the feelings of a work space.RhinoCommon with C# seminary in the eCAADe 2010: Future Cities workshop, at the ETH, Zürich.In the air an atmospheric pollution visualization software for the city of Madrid and a physical prototype for facades. Develeped by an interdisciplinary team, coordinated by Nerea Calvillo and Victor Viña, during Visualizar´08: Database City at Medialab Prado Madrid.

Creative programming workshop I and II at Medialab Prado Madrid: visual programming and interaction in the Processing environment.

Creative electronics workshop at Medialab Prado Madrid: basic concepts of circuits and physical interaction and programming of sensors in the Arduino environment.

2010

2011

2009

2008

2009

WorkshopsMarch

September

June

February

November

CollaborationsOpera Body, an experimental interactive installation on spatial visualization through sound experience, relating body, space and sound, installed at the Contemporary Art Museum of Santiago de Compostela (CGAC).

2010 July

Working team for the restoration of the public space of the School of Architecture of Madrid, directed by Ecosistema Urbano as a result of an Honourable Mention in the competition organized by the same School.

2007 December

Base and working designs at Eduardo Navadijos and Csaba Társoly S.L. Ellaboration of the project for a Umbraculum and children´s games garden in Boadilla del Monte, Madrid, entry in the Wan Awards 2009 and fi nalist in the X Biennial of Spanish Architecture and Urbanism.

2006

As a lecturerLecturer on Generative Design in Architecture in the 3rd Symposium of Design and Teaching during the 4th Biennial of Iberoamerican Design at Matadero Madrid Centre of Design (BID).

Invited lecturer on Parametric Design in Architecture at the Parametric Studio (Taller Paramétrico) of the University San Pablo CEU Shool of Architecture.

December2012

2011 February

Teacher of Grasshopper in the courses of the Students Association at the School of Architecture of Madrid (basic and advanced levels).

2010 -2013

Assistant Teacher of Parametric Design and Data Visualization for the Collective Housing Research Group (GIVCO), a R&D project of the Polytechnique University of Madrid (UPM).Invited teacher on digital/analogical fabrication and interactive tools at Estilo School to elementary students.

2010 June

Micropocessor programming with C++ masterclass at Medialab Prado Madrid. 2009 July

2011 January


RhinoCommon scripting with C# in Grasshopper and Rhino.Python in Grasshopper and Rhino 5.Custom Grasshopper components with Visual Studio.Drawing and image editing applications with Processing.Electronic and sensors programming with Arduino.Interactive interfaces programming with VVVV.Basic Python scripting in Autodesk Maya.Scripting with Javascript for the Adobe Creative Suite.Websites design with XHTML and CSS.

Parametric modelling: Grasshopper (with Kangaroo, Weaverbird, Geco, Elk, Firefly and gHowl).Environmental analysis: Ecotect, Winair.CAD: Rhinoceros, Autocad, 3D Studio MAX.Graphic Design: Photoshop, Illustrator, InDesign, Acrobat.Video editing: Adobe Premiere.Office automation: Microsoft Office and Open Office.

Software

Programming languages

Spanish: mother tongue.English: Certificate of Proficiency in English (University of Cambridge).French: DELF B1 (Centre International d´Études Pédagogiques).German: Mittelstuffen 1 (Goethe Institut).

Languages

199820012002

Voice and public speaking course at the Polytechnic University of Madrid.

Introduction to Physics simulation using Kangaroo in Grasshopper, Studio Mode online course.

ALGOMAD 2010, at the Shool of Arquitecture of El Vallès (Barcelona): Generative Components and Rhinoscript workshops.

Rhinoscript course at the Graphic Department at the School of Architecture of Madrid.

2011

2013

2009

2009

2010

Complementary education

Authorized Rhino Trainer: Rhino Level 1 and Rhino Level 2 courses at McNeel Europe.

July

January

June

April

Smart Geometry 2011: Building the Invisible, at CITA, Copenhagen. Authored sensing cluster, coordinated by Kyle Steinfeld (University of California, Berkeley), Kat Park (SOM) and Nick Novelli (CASE). Design of a prototype to monitorize and visualize the feelings of a work space.RhinoCommon with C# seminary in the eCAADe 2010: Future Cities workshop, at the ETH, Zürich.In the air an atmospheric pollution visualization software for the city of Madrid and a physical prototype for facades. Develeped by an interdisciplinary team, coordinated by Nerea Calvillo and Victor Viña, during Visualizar´08: Database City at Medialab Prado Madrid.

Creative programming workshop I and II at Medialab Prado Madrid: visual programming and interaction in the Processing environment.


2010

2011

2009

2008

2009

WorkshopsMarch

September

June

February

November

CollaborationsOpera Body, an experimental interactive installation on spatial visualization through sound experience, relating body, space and sound, installed at the Contemporary Art Museum of Santiago de Compostela (CGAC).

2010 July

Working team for the restoration of the public space of the School of Architecture of Madrid, directed by Ecosistema Urbano as a result of an Honourable Mention in the competition organized by the same School.

2007 December

Base and working designs at Eduardo Navadijos and Csaba Társoly S.L. Ellaboration of the project for a Umbraculum and children´s games garden in Boadilla del Monte, Madrid, entry in the Wan Awards 2009 and fi nalist in the X Biennial of Spanish Architecture and Urbanism.

2006

As a lecturerLecturer on Generative Design in Architecture in the 3rd Symposium of Design and Teaching during the 4th Biennial of Iberoamerican Design at Matadero Madrid Centre of Design (BID).

Invited lecturer on Parametric Design in Architecture at the Parametric Studio (Taller Paramétrico) of the University San Pablo CEU Shool of Architecture.

December2012

2011 February


2010 -2013

Assistant Teacher of Parametric Design and Data Visualization for the Collective Housing Research Group (GIVCO), a R&D project of the Polytechnique University of Madrid (UPM).Invited teacher on digital/analogical fabrication and interactive tools at Estilo School to elementary students.

2010 June

Micropocessor programming with C++ masterclass at Medialab Prado Madrid. 2009 July

2011 January

1980´’s

1980 1981 1982 1983 1984 1985 1986 1987 1988 1989

1990s

1990 1991 1992 1993 1994 1995 1996 1997 1998 1999

2001

2000

2006

2007

2008

2009

2002

2003

2004

2005

I am born

McNeel Europe

Medialab Prado

Medialab Prado Medialab Prado

Medialab PradoVisualizar´08: Database City at Medialab Prado Madrid: In the air cluster, coordinated by Nerea Calvillo and Victor Viña, assisted by Bestiario and Aaron Meyers. First development of the atmospheric pollution visualization software for the city of Madrid (www.intheair.es).

Creative programming workshop II: visual programming and interaction in the Processing environment.

Creative programming workshop I: visual programming and interaction in the Processing environment.

Rhinoscript course at the Graphic Department at the School of Architecture of Madrid (20 h.).


Authorized Rhino Trainer: Rhino Level 1 and Level 2 courses at McNeel Europe (40 h.).

Housing base designs, directed by Lorenzo Fernández-Ordóñez.

Competition of a commercial area in La Rioja.Reverse Arquitectura

Estudio Guadiana

Eduardo Navadijos and Csaba Tarsoly Base and working designs at Eduardo Navadijos and Csaba Társoly S.L. Ellaboration of the project for a Umbraculum and children´s games garden in Boadilla del Monte, Madrid, entry in the Wan Awards 2009 and finalist in the X Biennial of Spanish Architecture and Urbanism.

Espacio Disponible, a students competition for the restoration Madrid School of Architecture´s public space.

Co-founder, together with Guillermo Ramirez of Frikearq(www.frikearq.com), office oriented to research and teaching of Generative Design techniques, through which we have organized and collaborated in more than 30 courses and workshops and have trained more than 300 people, including graduate and posgraduate students and proffessionals from different backgrounds, mainly Architects but Engineers, Industrial Designers and CNC machining as well.

Assistant scholar at the Juan de Herrera Institute in Madrid School of Architecture’s Urbanism Department.

Madrid School of Architecture

Honourable mention

Working team for the restoration of the public space of Madrid School of Architecture, directed by Ecosistema Urbano.

University of Cambridge

Centre International d´Études Pédagogiques

Technical University of Madrid

English Language:Certificate of Proficiency in English

French Language: DELF B1 Degree

German Language:Mittelstuffen 1 Degree

Goethe Institut


Frikearq

co

lla

bo

rati

on

s/te

ac

hin

g/

pra

cti

ce

/w

ork

sho

ps/

co

urs

es/

ed

uc

ati

on

/


2010

2011

2012

2013

Architect Degree

I am willing to work with you!

Smart Geometry 2011: Building the Invisible, at the CITA,Copenhage in Authored sensing cluster, coordinated by Kyle Steinfeld (University of California, Berkeley), Kat Park (SOM New York) y Nick Novelli (CASE, Rensselaer). Design of a prototype to monitorize and visualize the feelings of a work space through the use of in-site sensors.

Smart Geometry 2011 - CITA, Copenhagen

eCAADe 2010: Future Cities, ETH - ZürichSeminary of RhinoCommon in C# environment, taught by Giulio Piacentino.

Voice and public speaking course (20 h.).

ALGOMAD 2010, at the Shool of Arquitecture of El Vallès (Barcelona): Generative Components and Rhinoscript workshops (40 h.).

Co-organizer and invited teacher in the workshop Cosy Parametrics, directed by Izaskun Chinchilla with students from the Unit 22 of The Bartlett (University College of London, UCL), the European University (UEM) and the Technical University of Madrid (UPM).

Co-organizer and teacher of Smartlab Granada, a workshop on generative design methods with creative purposes, in collaboration with the University and the Architectural Association of Granada.

Lecturer on Generative Design in Architecture at the 3rd Symposium of Design and Teaching at the 3rd Symposium on Design and Teaching, at Matadero Madrid.

Assistant teacher on Advanced Geometry and programming techniques in the Master of Advanced Architectural Techniques (MUTAPA) in the European University of Madrid (UEM).

Invited lecturer on Data Visualization in the Degree of Digitial Fabrication in the School of Architecture.

Teacher of Associative and Parametric Design courses (basic, advanced and scripting levels) for proffessionals and entrepeneurs, in collaboration with the University of Las Palmas and the School of Industrial Organization and financed by the European Social Fund.

Association for the Economical Promotion of Gran Canaria

Invited teacher of Parametric Design with Grasshopper in ALGOMAD 2011, seminary on generative methods in Arquitecture and Design.

Invited lecturer on Parametric Architecture by the Taller Parametrico at the Shool of Architecture of University San Pablo CEU.

Invited teacher of Parametric Design to the Collective Housing Research Group (GIVCO) of the proyect of R&D&i of the Polytechnique University of Madrid (UPM).


Contemporary Art Museum of Santiago de Compostela (CGAC) Installation of Opera Body, an experimental installation on spatial visualization through sound experience.

University of Granada

Biennial of Iberoamerican Design

University San Pablo CEU

University San Pablo CEU

European University of Madrid





BarcelonaTECH (UPC)

Polytechnic University of Madrid

The Bartlett - UCL

IE University of Madrid

Assistant scholar and teacher in the course Projects of Parametric Architecture (Proyectos de Arquitectura Paramétrica) of the Architectural Projects Department in the School of Architecture of Madrid through an Innovation Educational Project of the Technical University of Madrid (UPM).

Teaching experience

Generative Design in Architecture

A four years experience teaching in different universities, such as the Polythecnique University of Madrid, the European University of Madrid, San Pablo-CEU University or the IE University Madrid, has given me the opportunity to learn with my students and test unconventional approaches to the design practice.

A generative design uses and explicits the instructions and relations system between a set of elements, either material or abstract, as generators of a design. It uses thoroughly or occasionally their practical applications in the design process so that we can ellaborate a design schema to generate a big amount of variations and help us select among the possible outcomes. These instructionsare defined as algorithms, that are, usually but not exclusively, expressed in mathematical language and are implemented in a set of commands in computational language so that it can be reproduced.

From 2009, I have always had the same intention: to promote the creative, interdisciplinary and unconventional of these generative methodologies in design. I have also tried to keep a practical approach to teaching as I believe in an active pedagogy.

Mainly, I have aimed our lessons to three fields:- construction of parametric and discriminative models and its relation with building techniques and programs.- data visualization and environmental analysis.- physical and nonlinear systems simulation and recursive models.

Environmental data visualization. Dwellings combinatorics.

Different roofing design posibilites according to wind site analysis.

Masterclasses in the European University of Madrid, Master in Advanced Architectural Design (MUTAPA).

SmartLABGranada2013, a workshop on generative design methods for creative purposes

ALGOMAD 2011, a seminary to promote the use and understanding of generative desgin tools, at IE University Madrid.

Teacher of Parametric Design for the Collective Housing Research Group (GIVCO), a R&D project of the Polytechnique University of Madrid.

Courses in the Association of Economical Promotion of Gran Canaria, in collaboration with the University of Las Palmas and the European Social Fund.

Teacher of Grasshopper (basic and advanced) in the Students Association of Madrid School of Architecture.

Co-founder, with Guillermo Ramirez, of Frikearq, a practice oriented to research and teaching of Generative Design techniques. Since 2009, we have organized and collaborated in more than 30 courses and workshops and trained more than 300 people, including graduate and posgraduate students and proffessionals from different backgrounds, mostly Architects but also Engineers, Industrial Designers and CNC machining.

SmartLAB Granada

It was my first collaboration on organization and conception of an entire workshop from the very beginning, both in the practical, course, workshop and presentations, and conceptual side, approach, structure and topics covered.

The goal was to comunicate the participants a creative, multidisciplinary and prejudice-free use of generative design tools. With that base, we divided the workshop in three interrelated parts with different objectives:

- Intensive course- Design studio- Presentations and final crit

In the first part, I taught three sessions with different main topics and its application in three scales of design:

- Session 1_city scale - neighbour scale [data visualization]: we focused on the capacity of generative tools of being huge managers of information.- Session 2_builging scale - furniture scale [construction of generative and parametric models]: we studied the capacity of generative tools to create multiplicity of results of the same design. We also gave particular importance to environmental values in design.- Session 3_mecanism scale - fabric scale [simulation of physical models]: we speculate on the possibility of generative methodologies to help us deal with self-organizing and nonlinear models, which would lead us to try to cope with indeterminacy in design.

An interdisciplinary workshop on generative methods with creative purposes in design. It was aimed for professionals and students from different backgrounds: Art, Architecture, Industrial design and Engineering and organized in collaboration with the University and the Architectural Association of Granada, where it took place from 28th January to 1st February of 2013.

Several screen captures of the workshop´s website.Physics simulation class exercise.

Different moment of the workshop.

Correlative to the course, we had purely practical workshop sessions in which the students, organized in groups, developed the design of different projects, previously selected, with the technical assistance of the teachers of the workshop and trying to apply the notions and competencies acquired in the course.

I was in charge of five, diversely oriented, groups and projects. Here, I add a summarized explanation of their work:

- Solsticial Urbanism: Jorge Caminero, Architect and PhD student in Madrid Shool of Architecture, hipothesized on the possibility of the existence of a direct relation between the proportions of Architecture and its latitude, what he called solsticial rectangle. He wanted to build a research tool to evaluate different building shapes and its relation to sun position. Eventually, his intentions aimed to ellaborate a generative urbanistic tool based on the proportions on that solsticial rectangle.- Nazarhino: Sergio Álvarez, Final Project student, was interested in exploring islamic patterns. He studied the decorative models of some spaces of tha Alhambra in Granada and managed to succesfully represent spatial structures from those patterns.- Tokyo Center: Juan Sánchez and Álvaro Tejada, Architects, wanted to use their project to test the how generative tools could help them in the development of a competition in Tokyo. Their work focused on the LED facade design and they explored the reactive possibilities of that sort of Architecture.- Solar and movement reactive skin: this group was composed by two italian Architects, Andrea Conti and Erika Mazza, along with two Final Project students, Javier Fernández and Juan M. Sánchez Muñoz, developed a project on panelling a surface according to solar incidence.- Dynamic urbanistic data analyzer: Juan Bachs and Elena Lucena, Final Project students, wanted to build an interface for finding optimal locations for certain building programs, according to socioconomic and urbanistic data. They managed to create a simple locator for several programs, such as markets and schools, in a coastal area of Granada, implementing proximity and clustering algorithms.

Finally, on the last day of the workshop, we had a critical session with invited lecturers from diverse origins, in which both the participants showed the projects developed during the workshop and the teachers made a presentation of their work. We had:

- Ana Belén López, Polythechnique University of Madrid, PhD researcher and winner of the Arquimede Prize for the best project of that university for Intimacy patterns, relating urbanism and sex.- José Luis García del Castillo, Harvard GSD PhD researcher on computational design and digital fabrication- Javier Fernández Gallego, Architect, Design Studio professor in the University of Granada.- Roberto Molinos, MArch Building Structures, Polythechnique University of Madrid, professor in IE University Madrid.- Rafael Urquiza, PhD Architect, Universtiy of Malaga, MArch in Digital Architecture, RMIT.

Family picture.Juan Bachs and Elena Lucena urban locator project.

Erika Massa and Andrea Conti solar reactive surface.

Sergio Álvarez research on Alhambra´s geometrical patterns.

Posibilidades

Podemos llegar a representaciones mucho más complejas.

Trabajo

Asignamos con las distancias medias calculadas una densidad a cada punto de la malla fabricada a la que se le asigna un gradiente de color según su valor.

Trabajo

Para mejor visualización hacemos corresponder un circulo de radio variable según el valor de densidad de cada uno de esos puntos. Repetimos el procedimiento para cada valor que queremos analizar pero siempre con la misma malla de referencia.

Conclusión

Con este procedimiento es posible relacionar datos de distintas listas a partir de los cuales se pueden sacar conclusiones para ubicar futuras actuaciones en el territorio seleccionado. Se puede hacer una comparativa de densidades en distintas localizaciones simplemente cargando el documento de otro lugar.

Trabajo

Creamos una malla (MESH) con unos valores de precisión variables a partir de la cual se miden las distancias mínimas (CLOSEST POINTS) de los puntos calculados de cada valor.

Punto de densidad media de área construida

Centros de referencia

Cosy Parametrics, Unit 22 - The Bartlett

Cosy Parametrics was a five day intensive workshop an experimental workshop on digital techniques and its relation with domestic and traditional design and fabrication that took place in Madrid School of Architecture in 2011 between December 2nd and 7th. The workshop had an intensive course on parametric design techniques as well as a design studio, with assistance for the development of the students projects. All that was combined with talks from relevant Madrid based practices and collectives and ended with a final jury with invited teachers from those universities.

The goal of Cosy Parametrics was to detach parametric techniques from its usual figuration of socially isolated proposals. The workshop had an speculative intention on diverse digital techniques, of design and fabrication, in order to explore if they can be used to produce designs in which the domestic, warm and delicate can have a place. We dealt with vernacular techniques easily fabricated but cumbersome to represent and we speculated as to wether, besides geometric conditions, it is possible to parametrize programmatic, environmental and economical strategies.

Along with my partner in Frikearq, Guillermo, I taught the intensive course and assist the studio design. We prepared specific examples of modelling vernacular objects and fabrication techniques, which were used in the students designs. We translated into geometric and logic models, things such as crochet or cross-stitching.

As for the studio, we organized the students in teams with one british student with two or three other Spanish student, who also had to come from different universities. They had to agree on a unique solution that would combine their previous designs and ideas. That proposal should take into account geometrical, programmatic and building parameters at the same time and from the earliest stages of the design development.

I was invited to teach in Cosy Parametrics, an experimental workshop on digital techniques and its relation with domestic and traditional design and fabrication. Directed by Izaskun Chinchilla and Carlos Jiménez, professors at The Bartlett (UCL), with undergraduate, graduate and End of Degree students from different Spanish universities: the European University, the University San Pablo-CEU and the Polytechnique University of Madrid, and from The Bartlett´s Unit 22.

Several exercises whe did during the course: mathematical and physical modelling of objects and fabrics.

A couple of pictures of different moment of the course.

I helped the students develope their work, under our Izaskun and Carlos’ supervision. My task was structuring solutions for each project he assisted, relating geometric, programmatic and constructive conditions.

The first day of the workshop we made a theoretical introduction to the subjects and did a presentation of our work and projects and we presented some of the exercises we will be doing during the workshop.

Combined with the course and design studio, we had presentations by diverse young Spanish collectives, such as Zuloark or pkmn Architects.

In the jury, we had several professors from different university who criticised the students´ outcomes. Among the invited teachers, we had Andrés Perea, and David Santos Mejía, head of School, from San Pablo-CEU University, Carlos Arroyo and Langarita-Navarro Architects, from the European University of Madrid and Nieves Mestre, from the IE University Madrid.

Project 2

Project 3 References and Precedence

There are many presidencies of kinetic walls and installations, but out real inspiration was the sunflower and its ability, when it is only a bud, to track the sun across the sky for a full 180 degrees, called Heliotropism. The default position is facing east, so that is why our installation can be manipulated to face only only direction.

Model Stills Showing the tracking of the model with the movement of the sun

Plan

9 am 11 am

1 pm

1 pm

3 pm 5 pm 7 pm

Spring Summer

Autumn Winter

GROUP 10 PATRICIA SUÁREZ MARTÍN + PAUL MC MANAMON + GABRIEL HERNÁNDEZ RODRÍGUEZ



OUP 10 ATRICIA SUÁREZ MARTÍN AUL MC MANAMON ABRIEL HERNÁNDEZ RODRÍGUEZ

Group work by Megan Townsend, Alvaro Estúñiga and Javier Rueda.Transportable station design by Julian Huang, Ángeles García y María Abreu.

Paul McManamon, Patricia Suárez y Gabriel Hernández group.

Sinan Pirie, Akmal Azhar & Esther Rodríguez Ramos final presentation.

Final day jury. Family picture.


ALGOMAD 2011

I conducted a seminary on parametric design to graduate, postgraduate students and teachers. Along with my partner in Frikearq, I taught a two-days intensive seminary on parametric modelling with Grasshopper, the algorithmic modelling software. The course had a full registration, with 30 attendees, and was a complete success.

The last day of the seminary, I also helped the students develop their own designs and prepare them for digital fabrication in the IE-University´s 3d-printer and laser cutting machines.

Algomad is a seminary on generative tools for Architecture and Building Construction Design, that started in 2010 and takes place, alternatively, in Barcelona and Madrid. 2011´s edition had two-days intensive courses on different software with talks and a last day of digital fabrication and final presentation. It took place at IE University in Madrid and Segovia campuses.

Trabajo con sensores, en entorno Arduino, y proceso de construcción del prototipo.

Research

Building elements assembly with artificial vision and augmented reality(on course)


Collective Housing Research Group

GIVCO is a consolidated research group within Madrid School of Architecture Department of Design. It develops his work from a shared habitat understanding as possible and necessary forms of generators of contemporary cities. From the basis of a deep, sistematic and transmittable knowledge of relevant 20th residential designs, the group´s research efforts focuse on testing, validating and, if possible, improving the potential of those designs. These researches aim to start a debate between those examples and current collective housing projects concerning typological emergence, habitability limits and housing developments management processes. The group is composed by five research professors and five pre-doctoral researchers.

I was responsible, along with my partner in Frikearq, for teaching parametric analysis processes and data visualization methodologies. The members of the group wanted to have a dynamic, stable and fast alternative research tool so they could tmanage the huge amount of data they were coping with and translate Architectural working drawings into information that could be measured and visualized. At that time, they were doing all that work manually, which was a cumbersome task.

In order to focus on the research capabilities of generative tools, we prepared an intensive course, using desgins from various contemporary Architects, such as Junya Ishigami, Smouth and Allen, Eduardo Arroyo or Sou Fujimoto. The course consisted of the following parts:

- a theoretical introduction on the capabilities of parametric tools applied to research, using generic examples of geometric analysis, which they could use in their housing units plans studies. - practical exercises on how to translate that documentation into mathematical entities so that it could be easy to analyse some housing parameters they were studying. - ellaboration of efficient data visualization tools with real-time connection.

Our audience was composed by seven posgraduate students, two of them, pre-doctoral researchers, and two research professors.

I collaborated as a teaching assistant of Parametric Design and Data Visualization for the Collective Housing Research Group (GIVCO), a Polytechnic University of Madrid research and development unit in November 2010.

Some Spanish collective housing designs, that GIVCO used as research material.

Satellite Settlement of Caño Roto (Stages I-II) : A. Vázquez de Castro, J. L. Íñiguez de Onzoño, Madrid, 1957-63.

Residential Building on Muntaner St. : José Luis Sert i López, Barcelona, 1929-31.

Some of the practical examples we did during the course.

Lars Astrand, “Breeding tables”. No.Mad, Paris Olympic villa comp

A picture of the course.

Junya Ishigami, Kanagawa Institute of Technology. Sou Fujimoto, Final wooden house.

0252

0282

02

069

0175

02

0230

0114

0178

0250

0187

0222

0200

0282

0238

0122

0282

0113

0121

032

0205

0248

0282

0271

0200

0171

086

070

015

0282

093

0264

0112

0176

0207

0154

010 016

052

016

087

0162

041

050

059

068

0263

0282

0277

0237

0225

0190

0224

0172

0272

0136

019

01307

0203

00

045

034

076

067

075

0239

090

0110

0135

0126

0245

0146

0209

0157

05

0100

01

05

077

01230119

0139 0142

027

0160

0239

0183 0195 0196

0226

0223 0229

0235

073

0262

082 084

0282

0185

0249

070

0241

0226

058

0216

051

01890188

0179

0194

033

0155

0279

0269

0198

095

0109

0215

0106

014

0273

06

021

069

0127

031

088

0280

0193

0236

066

0156

0102

088

0261

0109

095

0114 0116

0148

0121 0123

0282

0128

0282

0108

0282

0149

00 03

062

0282

038

0120

017

022

063

03

0282

0214

051039

012

0111

064

0129

033

0274

023

025

0151

029

031 034 036

0170

0181 0187

045 047

0194

052

0257

0243

0227

061

063

0265

0233

0230

0247

0260

077

0282 0282

0282

0282

0173

081

0275

078

0278

074072

0254

0270

066

0232

0228

0228

0189

057

0217

0199 0209

0191

0192 0197

044

0251

0193

0269

0198

035

0164

0220

0144 0152

026

0145

0218

043

020

0130

017

015014

0268

037 046 050

06

0202

089

047

00

02120204

0282

093

041

01

0206

0267

0282

048

023

089

029

0235

092

056 061054

097

0133

099

071

074

0266

0104

079 081 082 084

0110 0111

091 0105

0262

097

0117

01040101

0125

0265

0243

0124

0282 0282 0282

0129

0282

0282

0219

0147

0271

0150

0282

0282

0282

04

0282 0282

0282

044

0282

0141

0211

0211

0174

018 019

09

083

0186

096

0278

036

024

085

0108

026

0240

08

053

010 011

0122

0107

0260

0216

0128

0117

094

0217

0132

0272

021 022

0236

024

0134 0138

0219

0153

0140

030

0158

0282

0165 0167 0177

037 038 039

040

0182

0223

0246

0185

046

0191

048 049

0253

0207

053 054 055 056

0220 0222

0214

0245

062

0244

064 065

0242

067

0277

0238

0255 0256 0258

0231

02680261

0280

079

0270 0282

0184

0233

083

0282

0183

0258

085

049

0182

080

0281

0232

0181

076

075

0259

0180

0186

0276

071

0179

0257

0234

0229

0178

0227 0231

0188

0177

0224

060

0213

0176

0221

0206

0218

0175

0256

02100208

0174

0225

02030202

0173

0190

0192

0184

0172

043042

0180

0171

0255

0276

0169

0170

0168

0221

0166

0169

0195

01610159

0168

028

0196

0163

0167

0254

0143

0197

0166

0266

0273

0212

0165

0131

018

0137

0164

0199

01270126

0163

0253

0101

0120

0162

055

09

0201

0161

027025

08

0160

04

020

0213

0159

0252

0115

07

0158

0201

028

0242

0157

0282

0205

011

0156

012 013

0210

0155

0251

0275

0281

0154

032

0234

035

0153

059

042

090

0152

0259

091

030

0151

0250

058 060

0150

068

096

065

0149

098

057

0237

0148

0100

072 073

0147

0249

0103 0204

0146

0105

078 080

0145

0107

0116

094

0144

086 087

0240

0143

0248

092 0103

0142

0106

0241

0115

0141

0112 0113

0118

0140

0119

0118 0124

0139

0247

0274

0263

0138

098

040

0125

0137

0282

0244

0282

0136

0282

0282

0130

0135

0246

0102

0282

0134

0215

0282

0208

0133 0267

0282

0279

0132

0282

099

0282

0131

0264

A=-2.5º

A=-28ºA=-26ºA=-51.1ºA=-57ºA=41.1º A=-32.4ºA=35.2ºA=57.2ºA=54.3ºA=47º A=-47.1ºA=-2.9º

A=59.7º

A=-46.9ºA=58.9º

A=53.3ºA=-43.6º

A=24º

A=-76ºA=64.2ºA=-56.3ºA=57.7º A=-58.5º A=77ºA=-43.9º A=-22.5ºA=-34.2ºA=-53.8º

A=61.1º

A=-88.2º A=-80.5ºA=83.3º

A=-20.6º A=-2.8ºA=4.9ºA=-8.6ºA=69.2º

A=44.3º

A=44.5ºA=8.1ºA=-15.4º A=38.6ºA=29.7ºA=16.3º

A=33.4º

A=44.1º

A=38.9ºA=38.2º

A=-45.9º

A=-58.3ºA=47.3º A=-49º A=24.9ºA=59.2ºA=26.6ºA=-11.7º A=-56.4ºA=-64.8º

A=-41.6º

A=50.1º

A=66.4º

A=18.1º

A=-74.1ºA=36.5ºA=70.4º A=89ºA=41.2ºA=69.9º A=82.5ºA=25.4ºA=88.1º

A=74º

A=83.9º

A=76.1º

A=86.7ºA=82.9º

A=27.2ºA=71.2ºA=65.7ºA=-70.7º A=58.4º

A=4.7º

A=22.8ºA=-26.5º A=56.2ºA=40.9ºA=-10.5ºA=-31.2º

A=62.6ºA=-53.8º A=51ºA=62.4º A=20.2ºA=-34º A=-16ºA=-40.3º A=-2.7º

A=27º

A=46.5ºA=64.6º

A=40º A=-38.1ºA=8.2ºA=-6.5º A=18.2ºA=-18.2º A=29.2ºA=14.7º A=18.2ºA=-11.8º A=18.2º

A=18.2º

A=18.2º A=18.2ºA=18.2º

A=18.2ºA=18.2ºA=18.2º A=18.2ºA=18.2ºA=18.2º A=18.2ºA=18.2ºA=18.2º A=18.2ºA=18.2º A=18.2ºA=18.2º

A=18.2ºA=18.2º

A=18.2º

x=1.0 x=0.9

x=1.1 x=1.1

x=1.6

x=1.6

x=0.7x=0.6x=0.9x=1.4x=1.2x=1.0x=0.9

x=1.4x=0.6x=1.0 x=1.4 x=1.0x=1.0 x=2.0x=0.6x=0.6x=0.7x=2.0x=0.6

x=1.1

x=0.6

x=1.2

x=1.0

x=0.8

x=1.2

x=0.8x=0.6x=0.6x=1.2x=2.0x=0.6x=0.6 x=2.5x=0.6x=2.0 x=2.0x=0.8

x=0.8x=0.7x=1.0x=1.4x=0.6

x=0.6x=0.6

x=1.1

x=0.7

y=2.0y=2.0y=2.0y=2.0y=2.0y=2.0 y=2.0

x=1.1

y=2.0

x=0.8

x=1.0

x=1.1

x=1.1

x=0.6

x=0.8

x=1.1

x=1.0

x=0.8

x=1.0

x=1.1

00

x=0.6

x=1.6

x=1.2 x=0.8

y=2.0

x=0.8

x=1.2

x=0.8

x=1.4

x=2.0

x=1.2x=1.0

x=0.8

x=1.0

x=1.1x=0.8

x=1.0

x=1.2x=1.1

x=0.8

x=1.1

x=1.0

x=1.2

x=0.8

x=0.8

x=2.0x=2.0

x=1.1

x=0.6

x=1.1

x=0.9 x=1.6

x=1.6

x=1.1

x=3.3

x=2.5

x=1.1

x=0.7 x=0.6

x=1.1

x=1.2

x=1.1

x=1.6

x=1.0

x=1.2

x=1.2

x=0.8

A=18.2ºA=18.2º

x=1.4x=0.8

A=18.2º

y=2.0y=2.0

A=18.2º A=18.2º

A=18.2º

y=2.0y=2.0

A=18.2º

A=18.2º

y=2.0y=2.0

x=1.0

A=18.2º

x=1.4

y=2.0 y=2.0

x=0.9

y=2.0

x=0.8

y=2.0

A=-1.7º

x=1.0x=1.0

y=2.0

A=-33.9º

y=2.0

x=0.9

y=2.0

A=-8.3º

y=2.0

x=0.6

x=1.1

y=2.0

y=2.0

x=0.6

y=2.0

A=20.5º

y=2.0

x=1.1x=1.1

A=-26.6º

y=2.0y=2.0

x=1.1

A=-20.8º

y=2.0y=2.0

x=1.2x=0.7

y=2.0y=2.0

x=0.9

A=16.5º

y=2.0

x=0.7x=1.2

A=-26.6º

y=2.0

x=1.1x=0.8

A=74.8º

y=2.0y=2.0

x=0.7

y=2.0y=2.0

x=0.9

x=1.0

A=-82.6º

y=2.0y=2.0

x=1.0

A=87.3º

y=2.0y=2.0

x=1.1

A=71º

x=1.1

y=2.0y=2.0

x=1.6

y=2.0

y=2.0

x=0.6

A=-61.1º

x=0.7

y=2.0y=2.0

A=44.2º

x=1.6

y=2.0

x=0.9

A=43.4º

y=2.0

x=1.4x=1.6

y=2.0 y=2.0

x=1.0

y=2.0

A=21.3º

y=2.0

x=1.2 x=0.7

A=-42.2º

y=2.0y=2.0

x=1.0

A=64.5º

y=2.0y=2.0

x=0.8x=1.6

y=2.0y=2.0

x=0.8

A=-17.1º

y=2.0y=2.0

x=1.1

A=31.8º

x=1.6

y=2.0y=2.0

A=11.6º

x=1.4

y=2.0

x=1.0x=0.8

y=2.0

x=1.2x=1.2

A=-39.9º

y=2.0

y=2.0

x=2.0

A=7.4º

y=2.0y=2.0

x=1.4

A=-49.8º

x=2.0

y=2.0y=2.0

x=1.4

y=2.0y=2.0

x=0.7

A=-46.4º

x=0.6

y=2.0

y=2.0

A=-47.4º

x=0.6

y=2.0y=2.0

A=25.9º

x=1.1

x=1.1

y=2.0y=2.0

x=1.6

y=2.0

x=1.1

y=2.0

x=0.8

x=1.1

y=2.0

y=2.0

x=2.0

y=2.0y=2.0

x=1.1

x=0.8

y=2.0y=2.0x=0.8

y=2.0y=2.0x=1.4x=1.1

y=2.0y=2.0

y=2.0

y=2.0y=2.0

y=2.0y=2.0

y=2.0y=2.0

y=2.0

y=2.0

y=2.0y=2.0

y=2.0

y=2.0y=2.0

y=2.0y=2.0

y=2.0

y=2.0y=2.0

y=2.0 y=2.0

y=2.0y=2.0

y=2.0

y=2.0 y=2.0

y=2.0y=2.0

y=2.0y=2.0

y=2.0

y=2.0y=2.0

y=2.0

y=2.0

y=2.0 y=2.0

y=2.0

y=2.0

y=2.0

y=2.0

y=2.0 y=2.0

y=2.0y=2.0

y=2.0

y=2.0y=2.0

y=2.0

y=2.0

y=2.0y=2.0

y=2.0

y=2.0y=2.0

y=2.0y=2.0

y=2.0y=2.0

y=2.0

y=2.0y=2.0

y=2.0y=2.0

y=2.0y=2.0

y=2.0

y=2.0

y=2.0

y=2.0

y=2.0

y=2.0

y=2.0

y=2.0y=2.0

y=2.0

y=2.0y=2.0

y=2.0y=2.0

y=2.0

x=0.7

y=2.0

x=1.1 x=1.6

y=2.0y=2.0

x=1.0

x=1.1

y=2.0

x=0.9

x=1.1

y=2.0y=2.0

x=0.9x=1.0

y=2.0

x=0.6

y=2.0

x=1.1

y=2.0y=2.0

x=0.9

x=1.0

y=2.0

x=0.8

x=0.6

y=2.0y=2.0

x=4.9

x=1.6

y=2.0

x=1.1x=1.1

y=2.0y=2.0

x=1.0

x=0.6

y=2.0

x=0.9x=1.2

y=2.0

y=2.0

x=1.0

x=1.0

y=2.0

x=1.1

y=2.0y=2.0

x=1.1

y=2.0y=2.0 y=2.0y=2.0y=2.0y=2.0 y=2.0y=2.0

y=2.0y=2.0y=2.0y=2.0

y=2.0y=2.0

y=2.0y=2.0y=2.0y=2.0y=2.0y=2.0 y=2.0y=2.0

y=2.0y=2.0

y=2.0y=2.0y=2.0y=2.0 y=2.0y=2.0

y=2.0

y=2.0

y=2.0y=2.0y=2.0

y=2.0

y=2.0y=2.0 y=2.0y=2.0 y=2.0

y=2.0 y=2.0

y=2.0

y=2.0y=2.0

y=2.0 y=2.0

y=2.0

y=2.0 y=2.0y=2.0

y=2.0y=2.0

y=2.0 y=2.0

y=2.0

y=2.0

y=2.0

y=2.0

A=-43.4º A=28.8º

y=2.0

y=2.0

A=-3.8º

y=2.0

y=2.0 y=2.0

A=19.9º

y=2.0

A=-19.4º

y=2.0

A=5.8º

y=2.0

y=2.0y=2.0

A=33.8ºA=0.6º

y=2.0 y=2.0

A=-4.1º

y=2.0 y=2.0 y=2.0

A=0.7ºA=-25.8º

y=2.0 y=2.0

A=-60.4º

y=2.0y=2.0 y=2.0

A=-31.6ºA=-38.5º

y=2.0 y=2.0

A=-44.2º

y=2.0 y=2.0 y=2.0

A=40.4º

A=-51.2º

A=-69º

A=-24.9º

A=1.5º

y=2.0 y=2.0 y=2.0

A=29ºA=-12.5º

y=2.0

y=2.0

A=11.8º

y=2.0 y=2.0 y=2.0

A=-34.1ºA=-44.2º

y=2.0 y=2.0

A=-26.8º

y=2.0 y=2.0 y=2.0

A=0.7ºA=-57.4º

y=2.0

y=2.0

A=18.9º

y=2.0 y=2.0 y=2.0

A=-60ºA=-62.9º A=26.9º

y=2.0

A=-3.7º

y=2.0 y=2.0 y=2.0

A=-25.4ºA=-64.2º

y=2.0 y=2.0

A=38.6º

y=2.0 y=2.0 y=2.0

A=-34.6º

A=-62.6º

y=2.0 y=2.0

A=-42.6º

y=2.0 y=2.0

y=2.0

A=19.2ºA=-4.5º

y=2.0 y=2.0

A=-16.3º

y=2.0 y=2.0

y=2.0

A=37.8º

A=-6.1º

A=73.5º

A=-37.6ºA=-40.2º

y=2.0y=2.0 y=2.0

A=-28.3ºA=-33.8º

y=2.0 y=2.0

A=-39.3º

y=2.0

x=0.9

x=1.6

A=-40.5ºA=-24º

x=0.9 x=0.7

A=-58.9º

x=1.1 x=2.5

x=0.7

A=35.5ºA=17.1º

x=0.7

x=1.6

A=49.2º

x=0.6

x=1.1

x=1.2

A=44.8º

A=68.8º

A=-55.2º

x=1.2

A=-78.8º

x=1.1 x=1.0 x=0.9

A=-59.8ºA=-31.7º

x=1.6

x=0.7

A=55.8º

x=1.1

x=0.6 x=3.3

A=-34.8º

A=-70.3º

x=1.1 x=0.7

A=-42.4º

x=1.1

x=1.2 x=2.0

A=-42ºA=-46.6º

x=2.0

x=1.2

A=44.5º

x=1.6 x=1.4

x=1.1

A=-56.7º

A=-64.9º

A=64.7ºA=-20.6ºA=64.5º

x=1.6

x=1.0 x=2.0

A=-57ºA=53.5º

x=1.2

x=0.9

A=71.8º

x=0.8 x=0.8 x=2.0

A=-26.9ºA=-35.1º

x=0.8x=1.1

A=65.1º

x=1.0x=1.0 x=1.1

A=-19.7º

A=-49.5º

x=0.7 x=0.9

A=-55.6º

x=1.1 x=1.2 x=1.4

A=-88.8ºA=-15.1ºA=-44.7º

x=1.2

A=-48º

x=2.0

x=0.6 x=2.0

A=-19.6ºA=-35.6º

x=2.0 x=0.8

A=-44.7º

x=0.7

x=0.8

x=1.1

A=-48.4ºA=88.7º

x=1.0 x=0.7

A=-53.7º

x=0.8 x=0.7x=0.7

A=-64.6ºA=75.6º

x=0.6

x=0.9

A=72.1º

x=0.7 x=0.6 x=0.6

A=6.8º

A=70.5ºA=-72ºA=75.6º A=51.7º

x=1.6 x=1.0 x=1.6

A=77.9ºA=61.7º

x=1.1

x=1.2

A=-49.4º

x=1.1

x=1.1

x=0.9

A=-82.6ºA=65.7º

x=1.1 x=1.1

A=-51.1º

x=1.1

x=0.8

x=1.4

A=46.4º

A=18.8º

x=1.4

x=0.7

A=38º

x=1.1 x=0.7x=1.0

A=-87.9ºA=55.7º

A=-30.1º

x=0.7

A=29.6º

x=0.8

x=1.1

x=0.6

A=52.2º

A=30.1º

A=18.2º A=18.2º

A=51.3º

A=18.2º A=18.2ºA=18.2º

A=43.4º A=39.4º

A=18.2ºA=18.2º

A=-45.4º

A=18.2º A=18.2ºA=18.2º

A=32.8º A=-76.7º

x=1.1

x=1.2

A=-34.2º

x=1.0 x=2.5 x=1.4

A=-73.9ºA=-4.9ºA=-38º A=-11.4º A=-10.2ºA=-30.8º

x=0.8 x=0.8

A=24.6ºA=74.7º

x=0.9 x=0.8

A=4.2º

x=0.8 x=0.7 x=1.1

A=34.7ºA=-1.2º

x=0.8

x=1.2

A=-18.1º

x=1.2 x=1.0 x=0.8

A=-19.4ºA=-32.4º

x=0.8

x=0.6

A=-36.9º

x=0.7

x=1.0

x=1.1

A=5.2ºA=-25.5ºA=-43º

x=1.1

A=79.1º

x=1.1

x=1.1

x=1.0

A=-1.3ºA=-20º

x=1.6

x=1.1

A=53.2º

x=1.1

A=38.2º



Innovative education programme

The goal of the Innovative education programme Think Architecture with parametric models: cross curricular space was to provide students with a solid theoretical and practical basis to ellaborate designs under the parametric paradigm in an interdisciplinary design studio scenario.

The main focus of this newly born course was the definition of mathematic models (geometric, logic, statistic, computational ...), that can be modified and optimized in real-time, to relate with environmental and thermodynamic parameters and values of the design. That is the reason why we had several collaborating assisting professors from other departments, both Mathematics and Physics, universities and practices, who contributed providing technical support and occasional talks on specific topics.

I acted both as an assistant in the development of the students’ designs and as technical support with digital tools. I also was responsible for some digital tools introductory lessons. We mostly used Grasshopper, the graphic algorithmic editor for Rhinoceros, for its simplicity but scripting, Processing and Arduino as well. Again, the course was not merely aimed to teach diverse digital techniques, although valuable for

I was awarded a research scholarship to collaborate in the start-up and teaching in a new undergraduate departmental elective course in Madrid School of Architecture´s Department of Design in 2010. It aimed to include parametric design techniques in Architecture Design practice. This course was the first to bring together three different School departments: the Department of Design, the Department of Applied Mathematics and the Department of Physics and Building Systems. As a result of this, two new courses on the same topic were included in the Department of Design postgraduate programme Master in Advanced Architecture Design in Madrid School of Architecture.

Several screen captures of the course´s website with some undergraduate students’ designs.

The use of both environmental data and Mathematical functions for environmental optimization was extensive during the course, like in the undergraduate students, Rocío García Peña and Pedro Torres, solar analysis design.


the students’ training, but to develop the students’ designs. Those techniques would only be put at the service of the students’ ideas and intentions to enhance their capabilities and creativity.

The course also had a collaborative structure, we organized the class in design team. We also ellaborated a web repository so that all the students could share their files and use them in their designs. The course had a full registration, with 45 students.

I also taught as an invited lecturer in the Master course that came as a result of the graduate subject in 2010-2011 academic year.

http://arquitecturaparametrica.dpa-etsam.com/20092010/http://innovacioneducativa.upm.es/proyectosIE/informacion?anyo=2010-2011&id=134

End of course design of the team composed by the undergraduated students Emilio Ortiz, Iria Gámez and Lucía Bentúe.

End of course design by Gerardo Marcos, MArch student, who made a research on the relation between speed, light and Architecture and ellaborated a continuos spacial structure from boundary conditions.

End of course design by the MArch student Ricardo Montoro Coso, who carried a research on organic skins and their response to environmental parameters, mainly growth conditions due to solar incidence.

* Next, I show the pages or slides of each lecture exactly as they were given. Therefore, the text in not translated.

Lectures *


Parametric Architecture, San Pablo-CEUUniversity

In this conference, we gave a brief historic introduction to generative design in Architecture, from Christopher Wren´s urban design for London after its fire in 1666 and the 51 churches’ project. We tried to link some historic designs and thinking with new design methodologies, associating them with our own classes, the projects we had collaborated and our own designs, which are included in the images on the left. We spoke not only about parametric design techniques but environmental issues, researches on design with sensors, real-time data, artificial vision and digital fabrication.

As for the other participants, Pablo Delgado showed his teaching work at the Parametric Studio; Vicente Soler, his collaboration in AMID.Cero9´s competitions; and, finally, Roberto Molinos, the refurbishment project of La Laguna Cathedral (Tenerife), his research on stadium´s grandstands geometric definition and his academic experience in Algomad.

Among the public, there were students from cross curricular design studio, coordinated by Rubén Picado and María José de Blas, several other teachers from the university, who showed their interest in the topics explained and we had some friends and students´ visit. In the end, the audience could ask their own questions and, eventually, there was an interesting debate on parametric design techniques with past and present Architecture.

Conferences on Parametric Design in Architecture at San Pablo CEU University School of Architecture Parametric Studio (Taller Paramétrico) in November 4th. The session was organised by Pablo Delgado, CEU University, with Vicente Soler, collaborator at AMID.Cero9, Roberto Molinos, IE University and Modelical, and Guillermo Ramírez and myself, from Frikearq.

Guillermo RamírezMiguel Vidal

www.frikearq.com

Universidad San Pablo CEU4 de febrero de 2011

51 churches, 1669. Christopher Wren.

algoritmo

datos

instrucciones que relacionan los elementos del diseño

entorno

Monumento del holocausto, Berlín. Peter Eisenman.

Estructura del Instituto Tecnológico, Kanagawa. Junya Ishigami.

In the airProyecto de visualización de la contaminación atmosférica de la ciudad de Madrid , desarrollado en VISUALIZAR’08 en Medialab Prado. Coordinadora: Nerea Calvillo.

Opera bodyInstalación experimental de representación del espacio a partir de ondas sonoras. Conceptualización y oordinación: Carmen Mazarira. Desarrollo de software: Enrique Esteban y Jorge Cano

algoritmo

resultado

datos

instrucciones que relacionan los elementos del diseño

conjunto de resltados

entorno

Estructura de la Mediateca de Sendai. Toyo Ito.

oportunidades

Cómo (NO) hacer un electrocardiofrecuencímetro casero

Plan para la reconstrucción de Londres, 1666. Christopher Wren.

datosentorno

Algunos ejercicios de nuestros cursos. Intentamos transmitir esta manera de trabajar en los proyectos tomando ejemplos de proyectos reales.

Cubierta del mercado de Santa Caterina, Barcelona. EMBT.

gestionar complejidad de información

Cómo (NO) hacer un electrocardiofrecuencímetro casero

Conclusiones a partir de visualización de datos

Condiciones de verano

Condiciones de invierno

diseño de procesos y no de un resultado


Simulación de incidencia eólica Visualización de información del entorno

Conclusiones a partir de visualización de datos

Condiciones de verano

Condiciones de invierno

Modelado de corrientes de aire

Adaptación a incidencia de viento

frikearq.com

¡Gracias!

adaptabilidad del resultado al entorno

diseño de procesos y no de un resultado


Collaborations


Opera Body

Opera Body is an exploratory visualization project on the influence of physical bodies in space through sound perception. The project was coordinated by Carmen Mazaira, March Architect, Ph.D. researcher and professor, and developed with the technical collaboration of Enrique Esteban, of Monster Electronics S.L., who was in charge of the audio analysis tool, and Jorge Cano, digital artist, responsible for coding the visualization tool.

The installation consist of a software with a visualization tool and real-time video and audio analysis. That software is connected to a set of sound and image capturing devices that monitor the space occupation. We used two sound channels with four microphones: two, below a wooden floor, for footsteps sensing and other two for environmental sound.

The visualization is based on the understanding of sound space as a sort of constantly changing voice box and in continous reconfiguration due to the interaction between the built environment and the people occupying that space.

Those concepts are translated to the visualization as a point cloud with density, dispersion and growing properties, that vary constantly according to the change of the room sound parameters. This point cloud will generate patterns that would keep trace of the intallation lifetime, adding value not the built boundaries but the sensorial relation between the people and their actions and the constantly mutable space.

An experimental installation on spatial visualization on the relation between body and sound experience, installed at the Contemporary Art Museum of Santiago de Compostela (CGAC) in 2010.

Some application screen shots.

Movement tracking test at the Galician Centre of Contemporary Art (CGAC).

Captura de software de visión artificial.

Planos de la instalación.

Capturas de aplicación de análisis de audio.


Espacio Disponible

Paneles del concurso.

Imágenes del proceso de obra.

Collaboration in the working team for the restoration of the public space of the School of Architecture of Madrid, directed by Ecosistema Urbano as a result of an Honourable Mention in the competition organized by this School in 2007.

Madrid School of Architecture patio refurbishment design was developed by a group of students who made up a working team from those students awarded or mentioned in a competition organized by the Head of the School in June 2007. That team was coordinated by Ecosistema Urbano, whose office members were part of the competition´s jury.

The competition´s conditions were to make a proposal that should take into account not only spatial and programmatic conditions, but also economical as well. Any design budget should be below €42.000.

3.63.63.63.63.63.63.63.63.6

4.06

4.53

5.05

5.12

4.93

6.44

5.55

4.67

4.98

5.95

3.441.535.164.094.89

prunus

chopo

chopo

cerezos

chopo

chopo

chopo

chopo

chopo

chopo

chopo

chopo

chopo

chopo

chopo

prunus

plátano

plátano

plátano

prunus

chopo

14 m.10 m.

st

sl

sección transversal e: 1/400st sección transversal_detalle

planta general

e: 1/100

e: 1/200

plátano ciruelosilvestre

chopoperal

cerezo

std

sección longitudinal_detallesld

sección longitudinal

mapa de árboles mapa teórico de sombras

sl

0 10 20 30

Para la cubrición del espacio entre el pabellón nuevo y el límite

de propiedad de la Escuela, se ha propuesto un sistema de

cables metálicos sujetos al murete de perímetro de la parcela y al

forjado de primer piso del pabellón nuevo que soporta una malla

de gallinero en la que crecerá una planta trepadora, que dará

sombra y hará más habitable este lugar. El ritmo del cableado es

el resultado de la separación promedio entre los árboles de ese

tramo de borde, con una rectificación para que se ajuste a la

longitud de la cara del pabellón a la que corresponde.

En la cara sur del pabellón nuevo, que da a la librería, se ha

planteado una pérgola en voladizo para dar sombra a los libros

en lugar de cubrir todo el espacio entre los dos pabellones.

cubierta vegetal [espacio disponible]

std

sld

elisa de los reyes garcía ló[email protected]é durant [email protected] villar [email protected] vidal [email protected] endaman nsé [email protected] fernández durá[email protected] ruiz gimé[email protected] hernández [email protected]és higueras [email protected]ús gó[email protected]

Autores:

Proy n°: Fecha:

Firma:

Por: plano nº

E.D.1

Título del plano:

MiguelVidalCalvet

Cubrición vegetalpabellón nuevo

dic. 2007 varias

PROYECTO BÁSICO Y EJECUTIVODEL ESPACIO ENTREPABELLONES DE LA ETSAM

Promotor:

Universidad Politécnica de Madrid

Orientación:

"espacio_disponible"Av. Juan de Herrera s/n

Oficina Técnica de la ETSAM

Colaboración:

Escala:Escala:

00001

ECOSISTEMA [email protected]

Arquitectos:

fase

E.D.10

Workshops


In the air

Digital visualization tool screen capture of various Madrid´s air conditions.

First version of an atmospheric pollution visualization tool and physical prototype. It was developed by an interdisciplinary team, coordinated by Nerea Calvillo and Victor Viña, during Visualizar’08: Database city, an international workshop that took place at Medialab Prado Madrid in 2008. This tool was later used to measure several cities’ pollution conditions, such as Santiago de Chile or Budapest in different workshops.

Several moments of team work at Medialab Prado Madrid. Workshop poster.

In the Air is a visualization project which aims to make visible the microscopic and invisible agents of Madrid´s air (gases, particles, pollen, diseases, etc), to see how they perform, react and interact with the rest of the city. The project constists of two prototypes:

- A web-based visualization tool (http://intheair.es/app/index.html), a dynamic model which builds up the space the components generate, where through data crossing behavior patterns emerge. This software takes real-time data from the city’s weather stations, which are uploaded to the council´s website, and locate and represent those data with a mesh. The coulours and height of the mesh are related to the air´s pollution damaging degree.

- A physical insallation for facades, the results of these data feed a physical prototype of what we have called a “diffuse façade”, a massive indicator of the air´s components through a changing cloud, blurring architecture with the atmosphere it has invaded and mediating the activity of the participants it envelops.

Physical prototype´s development process and final tests.

Smart Geometry 2011: Authored sensing

Smart Geometry : Building the invisible workshop, that took place in Copenhagen between 28th and 2nd April, and brought together a global community of innovators and pioneers in the fields of architecture, design, and engineering for discussion and collaborative research and experimentation. It hold a four-day intensive workshop with two final days with a public conference, a workshop exhibition and a public symposium and reception

The Authored Sensing cluster hypothesized that data-driven design must be supported by designed data. The cluster aims to inject intent and design into the typically passive process of data collection... The cluster promotes the production of designer-authored environmental datastreams: highly contingent, intrinsically idiosyncratic, free for public use that feed directly, intelligently and appropriately into new designs.

From this open starting point, the proposal, decided with the contributions of all the members of the team, was to design environmental data, in this case, related to an extensive occupation space, such as a working place. The project consisted in a physical prototype: a self-fabricated and trasportable sensorizing kit and a visualization software.

Developement of monitoring and visualization device that would capture and transmit the feelings associated to a work place. Under Smart Geometry 2011, in Copenhagen, coordinated by Kyle Steinfeld (University of California, Berkeley), Kat Park (MIT - SOM) and Nick Novelli (CASE - Rensselaer Polytechnic Institute). Visualization screenshots. The tool was built in the Processing environment

Visualization presentations.

Trabajo con sensores, en entorno Arduino, y proceso de construcción del prototipo.

School projects


Final Project

I based my final project on several strategies, all of them focused on tackling the current scarcity and crisis scenario. Those strategies included:- a productive landscape- an urbanistic planning of innovation infraestructures- a social activation and cooperation agenda

The solution I proposed focused on environmental and energetic concerns and tried to boost this impoverished area of the city by linking existing infrastructures and adding some new ones locally. The design´s building proposal allows subsequent growth and adaptability and the design´s environmental and energetic analysis, on which I based my design, was carried exhaustively and rigorously.

In my Final Degree Project, I chose my own brief, that involved a regeneration of a large deteriorated area next to a highway in the outskirts of Madrid. With this large scale intervention, I tried to link big public green areas with social infrastructures and housing developments based on energetic and environmental strategies.









i-MAD



Appendix 1Academic documents

Appendix 2Handbooks

frikearqdiseño generativo en arquitectura

miguel vidal calvetguillermo ramírez camarero

www.frikearq.com2011 www.frikearq.com

Si desea más información o tiene cualquier consulta o sugerencia, no dude en contactarnos en:

[email protected]

¿qué ofrecemos en frikearq?En la formación de diseño generativo existen, fundamentalmente, dos paradigmas - paradigma asociativo o paramétrico - paradigma discriminativo u optimización

Siguiendo esta clasificación, ofrecemos los siguientes niveles de formación:Curso de Grasshopper Nivel 1: modelado paramétricoSe trata de un curso de iniciación a Grasshopper. Para seguirlo no se requieren

conocimientos previos específicos. El objetivo de este curso es tomar contacto con Grasshopper y comenzar a fabricar y editar geometría con él. En este curso se aprende, entre otras cosas a: asociar formulaciones matemáticas a modelos paramétricos, a panelizar y triangular superficies, parametrizar estructuras sencillas y a elaborar algoritmos simples.

Curso de Grasshopper Nivel 2: modelado discriminativo y análisis ambientalLos objetivos de este curso son: conocer cómo fabricar y editar geometría de un modo

avanzado, trabajar con Grasshopper como herramienta de visualización de información, gestionar listas de datos, analizar modelos y optimizar de soluciones con algoritmos evolutivos.

Curso de scripting en C# con Grasshopper: modelado iterativo e interacciónEn este curso se aprende a elaborar modelados iterativos, capaces de heredar e

instanciar propiedades y comportamientos. Para ello se introduce al alumno en las nociones básicas de programación aplicadas al diseño generativo con C# y RhinoCommon en Grasshopper. Además, se tratan otros entornos de programación útiles para el diseñador como son Processing y Arduino y cómo conectarlos con Grasshopper.

La estructura básica de cada curso consta de una duración, en formato intensivo de 18 a 20 horas, sin embargo, el temario de cada uno de ellos se puede adaptar a diferentes formatos a petición. Todos los cursos están impartidos por dos Authorized Rhino Trainers con material propio, preparado exlusivamente para estos cursos.

Algunas ejercicios de los cursos: análisis solar de superficies, modelado con polígonos Voronoi, estructura de la Mediateca de Sendai.

¿qué es y qué nos ofrece el diseño generativo?

¿por qué Grasshopper?

¿quiénes somos y cuál es nuestra experiencia?

Consideramos que Grasshopper es el entorno más apropiado para comenzar su formación en diseño generativo.

Su principal virtud es que posee una interfaz completamente visual, lo que nos permite diseñar algoritmos que operan con datos y geometría de manera simple y muy intuitiva, sin la necesidad de aprender ningún lenguaje de programación. Al ser un plug-in para Rhinoceros, Grasshopper incorpora gran parte de sus comandos y funcionalidades y, además, utiliza Rhinoceros como entorno de visualización, de manera que podemos ver en tiempo real cómo afecta a nuestro modelo cualquier cambio que realicemos en Grasshopper.

Añadimos a esto que, Grasshopper es, actualmente, un software gratuito de libre descarga y que cuenta con una extensa y activa comunidad de usuarios y desarrolladores, que van añádiendo nuevas funcionalidades frecuentemente.

De ahí que Grasshopper se haya convertido en la herramienta estándar de modelado paramétrico en el diseño de Arquitectura.

Frikearq lo formamos Guillermo Ramírez y Miguel Vidal, ambos Authorized Rhino Trainers. Tenemos una experiencia de más de dos años en la formación de diseño generativo con Grasshopper, es decir, prácticamente desde los inicios del programa. Entre otras cosas:

- hemos impartido más de 20 cursos de Grasshopper entre cursos de nivel 1, nivel 2 y de scripting, entre los que se encuentra el primer curso de Grasshopper de Madrid.

- hemos tenido más de 200 alumnos entre estudiantes de grado y posgrado, docentes y profesionales del mundo de la Arquitectura, de la Ingeniería y del Diseño Industrial.

- publicamos nuestro propio manual de ejercicios de Grasshopper (consultar nuestra web), elaborado exclusivamente para nuestros cursos y que además, fue el primer manual de Grasshopper en castellano.

- somos formadores habituales de Grasshopper de los alumnos de la Escuela Técnica Superior de Arquitectura de Madrid.

- colaboramos activamente en el lanzamiento de una nueva asignatura del Departamento de Proyectos Arquitectónicos relacionada con este tema: Proyectos de Arquitectura Paramétrica, a través de un programa de Innovación Educativa de la Universidad Politécnica de Madrid.

- somos colaboradores de diseño paramétrico del Grupo de Investigación de Vivienda Colectiva (GIVCO) de la Universidad Politécnica de Madrid.

- hemos colaborado en el Máster Universitario de Técnicas Avanzadas de Proyectos Arquitectónicos de la Universidad Europea de Madrid.

- hemos sido conferenciantes invitados en la Universidad San Pablo CEU, por el Taller Paramétrico CEU y el Taller Transversal de dicha universidad.

- somos los formadores de Grasshopper de Algomad: Seminario sobre Métodos generativos en Arquitectura y Diseño, organizado por el IE University Madrid.

Además, consideramos fundamental estar en un proceso de formación continua, de ahí que participemos habitualmente y talleres y cursos en todo el mundo. Algunos de ellos son: Smart Geometry 2011 en Copenhaguen, eCAADe: Future cities en ETH Zürich, VISUALIZAR´08: Database city en Medialab Prado, Talleres de programación creativa

El diseño generativo en Arquitectura es la disciplina que elabora total o parcialmente diseños de Arquitectura mediante el uso de sistemas definidos por algoritmos, ya sean traducidos en software de computadoras o procesos matemáticos, mecánicos o aleatorios.

Algunas de las cualidades que nos aporta del uso de estas técnicas en el diseño de Arquitectura son:

- rapidez en la modificación de los proyectos: al elaborar el diseño de Arquitectura como un sistema interrelacionado, el cambio de una variable afecta a todo el modelo. - gestión de complejidad de información a gran velocidad: la definición algorítmica de nuestros diseños, y la ayuda en el cálculo de las computadoras, hacen que el diseño pueda verse afectado por una ingente cantidad de datos de diversas fuentes.

- generación y comprobración de multitud de resultados: un mismo algoritmo tiene la capacidad de generar múltiples resultados diversos, en función de la información de entrada. - análisis y evaluación de la validez de esos resultados: gracias a la interoperabilidad con otros software de análisis (estructural, energético, ambiental ...) podemos establecer parámetros que validen o no nuestros diseños.

- optimización de diseños: mediante la aplicación de algoritmos de evaluación y selección aplicados al proceso de generación del diseño, como algoritmos evolutivos, podemos introducir el sistema de generaciónde diseño en un proceso de búsqueda de una solución optimizada para unos factores concretos.

Curso en la Escuela de Arquitectura de Madrid. Curso en Las Palmas de Gran Canaria.

Smart Geometry 2011: Building de invisible, Copenhaguen, grupo Authored Sensing.

Taller de programación y electrónica creativa, Medialab Prado, Madrid.

Modelado según análisis de incidencia eólica con Grasshopper y Ecotect.

introducción al diseño generativo

con grasshoppermiguel vidal calvet

guillermo ramírez camarerowww.frikearq.com

diseño generativo

Christopher Wren, plan de reconstrucción de Londres tras el incendio de 1666.

Christopher Wren, tipos normalizado de edificación del plan.

Christopher Wren, 51 iglesias del plan de reconstrucción de Londres.

procesos

Guillermo Ramírez CamareroMiguel Vidal Calvet

www.frikearq.com

iniciación aldiseño generativo con Grasshopper

idea


www.frikearq.com


idea modelo matemático

(leyes de relación entre objetos)


www.frikearq.com



implementación(código fuente)



www.frikearq.com



implementación

información

(código fuente)(leyes de relación

entre objetos)


www.frikearq.com



implementación

resultados

información


entre objetos)


www.frikearq.com


2 paradigmas

- diseño paramétrico

- diseño discriminativo


www.frikearq.com


proceso de diseño paramétrico


www.frikearq.com


datos



www.frikearq.com


algoritmo

datos datos



www.frikearq.com


algoritmo

resultados

datos datos



www.frikearq.com


proceso de diseño discriminativo


www.frikearq.com


algoritmo

resultados

datos datos



www.frikearq.com


algoritmo

resultados

datos datos

evaluación



www.frikearq.com


algoritmo

algoritmo de selección

resultados

datos datos

evaluación



www.frikearq.com


algoritmo


resultados

resultados

datos datos

evaluaciónsí



www.frikearq.com


algoritmo


resultados

resultados

datos datos

evaluaciónsí

no


aplicaciones prácticas


www.frikearq.com


diseño del proceso y no de un resultado concreto.01


www.frikearq.com


diseño del proceso y no de un resultado concreto.

posibilidad de gestionar complejidad de datos.

01

02


www.frikearq.com




generación de soluciones adaptadas a condiciones de contorno.

01

02

03

grasshopper


www.frikearq.com


¿qué es Grasshopper?


www.frikearq.com


entorno de programación visual.

intérprete.

plug-in para Rhinoceros.010203



www.frikearq.com



intérprete.

plug-in para Rhinoceros.010203


algunas recomendaciones en el uso de Grasshopper


www.frikearq.com



esquema de flujo de datos antes de empezar.

intérprete.

sacar paneles informativos.

hacer comentarios de lo que se vaya haciendo.

personalizar nombres de componentes y poder hacer búsquedas.

plug-in para Rhinoceros.

higiene visual.

01

01

02

02

03

030405


algunas recomendaciones en el uso de Grasshopper


www.frikearq.com


El objetivo de este ejercicio es introducirse en el uso de Grasshopper como herramienta de diseño generativo, pasando por las utilidades fundamentales del programa. Utilizaremos colecciones y funciones numéricas para dibujar una superficie que, a continuación, panelizaremos. Y, una vez panelizada, la analizaremos con un vector solar básico para poder optimizarla.

ejercicio práctico00. objetivo del ejercicio


www.frikearq.com


01. trabajar con colecciones numéricas

A. Dibujar una matriz de puntos con dominios y un rangos.B. Afectar las coordenadas Z de esa matriz de puntos por una función.C. Dibujar la superficie a partir de esos puntos.

A. Dibujar una matriz de puntos con dominios y rangos.

Un dominio es un tramo continuo de la recta real, es decir, representa la colec-ción de todos los números entre esos dos valores. Dominio (domain) es un com-ponente cuya entrada son dos valores reales A y B y cuya salida es un intervalo continuo de la recta real y se escribe “A To B”.

Rango (range) se utiliza para generar valores diescretos a partir de un dominio continuo. Es un componente cuyas entradas son un dominio y un valor N, y cuya salida son valores numéricos. Es decir, toma un dominio continuo D y lo divide N veces, generando una colección de N+1 valores discretos.

A

N divisiones

N+1 valoresc d e B

A B

Conectamos la salida del rango a las entradas X e Y de PointXYZ y dibujará una hilera de puntos que tienen la coordenada X igual a la Y, puesto que las dos listas de números provienen del mismo rango:

(1,1) (2,2) (3,3) (4,4) (5,5) ....

Ahora, si nuestra intención es hacer una matriz de puntos, debemos cruzar estas coordenadas. Para ello, hacemos clic con el botón derecho en la parte central del componente Point, y seleccionamos Cross Reference. Esto quiere decir que a cada coordenada X (1, 3, 5, 7..) Grasshopper le va a hacer corre-sponder todas las coordenadas Y (1, 3, 5, 7..) produciendo una lista de pares de coordenadas de la siguiente manera:(1,1) (1,2) (1,3) (1,4) (1,5) ...

(2,1) (2,2) (2,3) (2,4) (2,5) ...


www.frikearq.com


B. Afectar las coordenadas Z de la matriz de puntos por una funcón.

C. Dibujar la superficie a partir de esos puntos

Descomponemos los puntos de la malla cuadrada base con Decompose Point y los “recomponemos” en otro punto XYZ (esta vez sin cross reference activo), tomando las coordenadas X e Y. La coordenada Z se generará en una función de n variables (f(n)) en la que introducimos, haciendo click con el botón derecho en la banda central del componente en edit expression, la ecuación del parabolide hiperbólico. El número de variables se define, también haciendo click con el botón derecho en la parte central del componente y luego yendo a input manager

Tomaremos, por ejemplo, una suma de seno y coseno con la siguiente forma:

(sin(b+(t*a))+cos(c+(t*d)))*f

En este caso, la variable t representarán todos los “momentos” por los que queremos que pase nuestra superficie, así que le pasaremos otro dominio, de tal manera, que podemos controlar la altura máxima y mínima de la superficie, y un rango para fijar el número de puntos, que tienen que ser tantos como puntos tengamos en la base. Puesto que el rango devuelve N+1 valores, pasaremos la cantidad de punto (list length) menos uno.

Dibujaremos la superficie a partir de los puntos anteriores con surface grid o surface from point. La entrada P será la última lista de puntos XYZ y U la cantidad de puntos en cualquiera de las direcciones de la superficie (esta superfice sólo funciona con plantas cuadradas) , que será la N del rango de la planta + 1.


www.frikearq.com


02. deformación de geometría: panelización de superficies

A. Dibujar la geometría que se quiere utilizar para panelizar la superficie.B. Dividir el dominio bidimensional asociado a la superficie.C. Replicar y deformar la geometría original sobre la superficie.

B. Dividir el dominio bidimensional asociado a la superficie.

C. Replicar y deformar la geometría original sobre la superficie.

A. Dibujar la geometría que se quiere utilizar para panelizar la superficie.

Dibujamos, en Rhino o Grasshopper, cualquier geometría para replicarla por las subdivisiones de la superficie original, en este caso, una superficie plana (Plane Surface). Dicha geometría se replicará mapeando una caja de referencia sobre dichas subdivisiones. Podemos tomar, también, cualquier caja de referencia. En este caso utilizamos el componente Bounding Box para encerrar la geometría que replicar en su volumen capaz alineado en el plano universal XY.

Necesitamos dividir el dominio bidimensional de la superficie con divide domain2. Las entradas U y V del divide domain2 se refieren a las coordenadas locales propias de la superficie.

Para panelizar la superficie utilizamos el componente Surface Morph, que toma una geometría contenida en una caja de referencia y la replica sobre una superficie deformándola de acuerdo a las coordenadas locales de la superficie.U y V las tomaremos de la división del dominio bidimensional y W corresponderá a la altura de la caja de destino sobre la que se mapeará la caja de referencia. En caso de utilizar más de una geometría para replicar, no debemos olvidarnos de activar la referencia cruzada para todas las geometrías cross reference.


www.frikearq.com


03. análisis solar de la superficie y visualización de resultados

Con el componente Point Polar dibujamos un punto que gira en torno al Origen. Uniendo con Vector Two Points el Origen y el punto polar, obtenemos la dirección de nuestro sencillo vector solar, con vector display podemos visualizarlo.Aquí estamos utilizando un vector solar muy básico, puesto que el objetivo del ejercicio es puramente didáctico. Dicho vector prodremos sustituirlo simplemente subreescribiendo la entrada del componente por otro más preciso, en caso de que necesitemos un análisis solar riguroso.

Referenciamos con dos Curve (icono de borde hexagonal) dos curvas dibujadas en Rhino, y conectamos ambos a la entrada S de un componente Loft. Con Divide Surface dividimos la superficie en puntos en los cuales conocemos el vector normal (salida N del Divide Surface). Un Flatten en las salidas N y P del Divide Surface nos libra de las sublistas.

1. Definir un vector en coordenadas polares.2. Dibujar y dividir una superficie.3. Comparar vectores y asignar color.4. Visualizar.

1. Definir un vector en coordenadas polares.

2. Dibujar y dividir la superficie.

Con un Angle comparamos los vectores normales (salida N del Divide Surface) con el vector solar (salida L de Line). A estos valores de ángulo les tenemos que asignar un color. Esto se consigue con Gradient. Con la paleta de Gradient definimos el espacio de color que vamos a hacer corresponder con los valores de ángulo, este espacio queda determinado entre los límites L0 y L1. Un ángulo de 0 radianes será rojo, uno de Pi será rojo también, y, en Pi/2, cuando los los vectores sean perpendiculares, la luz será rasante y le asignaremos el color verde.

3. Comparar vectores y asignar color.

El último componente, Preview, sirve para colorear: le asigna color a geometría. Nuestra información de color sale del Gradient, y la geometría a colorear son todos los puntos que salen del flatten de la salida P de Surface Divide.

4. Visualizar.

manual de ejercicios de grasshopper nivel I


www.frikearq.comedición 2011

índice

aplicado al diseño paramétrico de Arquitecturamanual de grasshopper nivel I

manual de grasshopper nivel I aplicado al diseño de arquitecturapor miguel vidal calvet y guillermo ramírez camarero

edición Noviembre 2010grasshopper v0.8.002

¿qué es y cómo funciona grasshopper?

tipos de datos y colecciones numéricas

indexación de datos, programación visual y componentes lógicos

creación y análisis de geometría

anexo

00 IntroducciónE01 Interfaz gráficaE02 Objetos. Tipos y modos de visualizaciónE03 Tipos de datos y modos de entrada. Introducción a listas.

E04 IntroducciónE05 Interfaz gráficaE06 Objetos. Tipos y modos de visualizaciónE07 Tios de datos y modos de entrada. Introducción a listas.



Enlaces de interés

conceptos básicosA

manual de grasshopper nivel IMiguel Vidal

Guillermo Ramírez

p0126

introducción

00. ¿qué es grasshopper?

01. ¿cómo se trabaja en grasshopper?

Grasshopper es un entorno de programación visual dentro de Rhino. Su principal virtud es que nos permite diseñar algoritmos que operan con datos y geometría de manera intuitiva sin la necesidad de aprender ningún lenguaje de programación. Al funcionar dentro de Rhino, Grasshopper incorpora gran parte de sus coman-dos y funcionalidades, además, utiliza Rhino como entorno de visualización, de manera que podemos ver en tiempo real cómo afecta a nuestro modelo cualquier cambio que realicemos en Grasshopper.

Grasshopper es una herramienta de diseño de algoritmos. Esto quiere decir que es capaz de encadenar una sucesión de comandos e instrucciones con entradas y salidas que son geometría y datos para producir un resultado. Esta manera de operar aporta gran flexibilidad de cara a manipular grandes cantidades de datos o datos variables en el espacio y el tiempo, pero condiciona enormemente nues-tra manera de trabajar.

Llevar una idea o proyecto a grasshopper no es una tarea sencilla. No basta con conocer la herramienta y sus comandos, hace falta ser capaz de traducir nuestra idea a un lenguaje matemático en primer lugar, y, en segundo lugar, a un lenguaje que grasshopper sea capaz de entender.

Por este motivo, mientras que grasshopper es una excelente herramienta para llevar a cabo proyectos que operen con gran cantidad de información, geometría, o múltiples variables y condiciones definidas con precision y rigor, grasshopper no es una buena herramienta para manejar procesos intuitivos o difusos, que tienen dificultad para ser traducidos a un lenguaje lógico.

Idea

modelo matemático

definición en grasshopper

0002. Recomendaciones de uso de Grasshopper antes de empezar

- Lo primero, guardar el archivo :-) para que se hagan archivos de autoguardado.

- Mantener un orden e higiene visual.

- Elaborar un esquema de flujo de datos de lo que se vaya a hacer.

- Al principio, sacar paneles de todo lo que se vaya haciendo.

- Cuantos menos cables, mejor.

- Comentar las definiciones.

- Cambiar los nombres de parámetros y componentes a nuestro gusto para poder

orientarnos mejor y hacer búsquedas rápidamente.

colecciones numéricas y tipos de datosB


Guillermo Ramírez

p0128

dominios, rangos y series

00. objetivo

01. componentes clave

02. procedimiento

El objetivo de este ejercicio es familiarizarnos con la creación de listas de números en Grasshopper. Para ello utilizaremos los componentes dominio, ran-go y serie para generar una colección de números que dibujarán una hilera de puntos primero y luego una matriz de puntos.

Dominio (domain) es un componente cuya entrada son dos valores reales A y B y cuya salida es un intervalo continuo de la recta real. Un dominio se escribe “A To B” y representa la colección de todos los números entre esos dos valores.

Rango (range) es un componente cuyas entradas son un dominio y un valor N, y cuya salida son valores discretos de la recta real. Es decir, es un componente que toma un dominio continuo D y lo divide N veces, generando una colección de N+1 valores discretos.

Serie (series) es un componente que genera una lista de valores ordenados a partir de un valor inicial A, un incremento o tamaño de paso N y una cantidad de valores C.

Para dibujar una hilera de puntos en la dirección del eje X utilizando los concep-tos anteriores, tendremos que seguir los pasos siguientes:

1. Sacamos un componente Series y conectamos unos sliders de número enteros a sus entradas A, N y C. El objetivo de esto es generar una lista de C coordenadas que empiecen en A y aumenten de N en N. Es decir, si le damos a nuestros sliders A, N y C los valores 1, 2 y 10 respectivamente, el componente series nos generará una lista tal que así (1, 3, 5, 7, 9, 11, 13, 15, 17, 19).

2. Conectamos la salida del componente Series a la entrada X del compo-nente Point. El significado de este paso es que asignamos cada valor numé-rico generado en la serie a cada coordenada X de una lista de puntos. Como conectamos varios valores a una entrada X, el componente dibujará varios puntos, tantos como hayamos especificado en C.

3. La hilera de puntos ya está terminada. Si ahora cambiamos los valores de los sliders podemos observar cómo afectan los cambios a la cantidad y la separación entre puntos.

4. Pero.. ¿ y si enchufamos una lista de números a la entrada Y de Point, qué ocurre? ¿cómo podemos hacer para que en vez de una hilera inclinada Grasshopper nos dibuje una matriz de puntos?

domain, range, series

A. Definición: dominio.B. Definición: rango.C. Definición: serie.D. Hilera de puntos.E. Matriz de puntos.

A. Definición: dominio.

B. Definicón: rango.

C. Definición: serie.

D. Hilera de puntos

E04

A

A

A

N divisiones

incremento N

N+1 valores

C valores

c

A+N

d

A+2N

e

A+3N

B

B

B


Guillermo Ramírez

p0129

dominios, rangos y series

Si simplemente conectamos la serie a las entradas X e Y de Point, Point hará exactamente lo que le pedimos, es decir, dibujará una hilera de puntos que tienen la coordenada X igual a la Y, puesto que las dos listas de números provienen de la misma serie:

(1,1) (2,2) (3,3) (4,4) (5,5) ....

Ahora, si nuestra intención es hacer una matriz de puntos, debemos cruzar estas coordenadas.

Intenta hacer una matriz de puntos tridimensional.

Intenta hacer una matriz de puntos como la anterior, pero que en el que cada punto esé elevado 1 unidad en la dirección Z con respecto al anterior.

1. Empleando lo aprendido en la lección de correspondencia de datos, hac-emos clic con el botón derecho en la parte central del componente Point, y seleccionamos Cross Reference. Esto quiere decir que a cada coordenada X (1, 3, 5, 7..) Grasshopper le va a hacer corresponder todas las coordena-das Y (1, 3, 5, 7..) produciendo una lista de pares de coordenadas tal que así:

(1,1) (1,2) (1,3) (1,4) (1,5) ....

(2,1) (2,2) (2,3) (2,4) (2,5) ....

(3,1) (3,2) (3,3) (3,4) (3,5) ....

donde cada elemento se combina con todos los demás.

E. Matriz de puntos.

ejercicio propuesto

ejercicio propuesto

E04


Guillermo Ramírez

p0130

parábola y espiral

00. objetivo

01. componentes clave

02. procedimiento

El objetivo de este ejercicio es familiarizarnos con el manejo de funciones. Us-aremos una serie para generar una lista de valores que serán afectados por una función. Visualizaremos los efectos de la función asignando los valores a coorde-nadas de puntos para dibujar una parábola primero, y luego una espiral.

Usando lo aprendido en el ejercicio E04, generamos una lista de valores con una serie. Conectando la salida de la serie a la entrada X de un componente Point, asignamos los valores de la lista a las coordenadas X de los puntos. El resultado es una hilera de puntos en X.

De momento sólo hemos operado con las coordenadas X. Sacamos un compo-nente función y lo conectamos a la salida de la serie, y la salida de la función la conectamos a las coordenadas Y de nuestro componente punto.

Conectamos un panel con el texto 0.1*x^2 . Con esto conseguimos afectar las coordenadas Y de nuestra hilera de puntos para que asciendan de manera cuadrática. El 0.1 es un coeficiente reductor que impide que la función crezca tan rápidamente que desaparezca de nuestra vista en Rhino.

Ahora aplicaremos tres funciones, una a cada coordenada. Aplicando una fun-ción cos(x) a la X y una sin(x) a la Y conseguimos que los puntos describan un círculo en planta.

Si conectamos lo valores generados en la serie directamente a la entrada Z de punto, o a través de una función x, los valores pasarán inalterados, dibujando una espiral que asciende linealmente en Z.

Si en vez de x escribimos cualquier otra función para la coordenada Z, el as-censo será diferente: prueba con x^2, o Ln(x)

series, function, point

A. Serie. Hilera de puntos en X.B. Parábola: aplicamos una función a las coordenadas Y. C. Espiral: aplicamos funciones a X, Y y Z.

A. Serie. Hilera de puntos en X.

B. Parábola: aplicamos una función a las coordenadas Y.

C. Espiral: aplicamos funciones a X, Y y Z.

E05


Guillermo Ramírez

p0131

paraboloide hiperbólico

01. objetivos

02. conceptos clave

03. procedimiento

- repasar la noción de dominio matemático- emplear las funciones de n variables- conocer cómo dibujar superficies a partir de fórmulas- entender cómo se define una superficie a partir de puntos

Dibujamos una malla cuadrada de puntos con un dominio, al igual, que en el ejercicio E01 - malla bidimensional de puntos.

Descomponemos los puntos de la malla cuadrada base y los “recomponemos” en otro punto XYZ (esta vez sin cross reference activo), tomando las coordenadas X e Y. La coordenada Z se generará en una función de n variables (f(n)) en la que introducimos, haciendo click con el botón derecho en la banda central del componente en edit expression, la ecuación del parabolide hiperbólico. El número de variables se define, también haciendo click con el botón derecho en la parte central del componente y luego yendo a input manager.

domain, range, f(n), decompose points, surface from points

1. Dibujar una malla de puntos base2. Dibujar los puntos del paraboloide a partir de la malla base con coordenadas Z modificadas por una función de varias variables3. Dibujar el paraboloide hiperbólico con una superficie a partir de puntos

1. Dibujar una malla de puntos base

2. Dibujar los puntos del paraboloide a partir de los puntos base

E06

Dibujamos el paraboloide con una superficie definida a partir de puntos (surface grid o surface from points). La entrada P será la últim lista de puntos XYZ y U la cantidad de puntos en cualquiera de las direcciones de la superficie (esta superfice sólo funciona con plantas cuadradas) , que será Nrango + 1.

3. Dibujar el paraboloide hiperbólico con una superficie a partir de puntos


Guillermo Ramírez

p0132

superficie por puntos - Miralles

01. objetivos

02. conceptos clave

03. procedimiento

Dibujaremos una superficie irregular cuya geometría viene dada por una función de la cual podemos controlar determinados parámetros. Para ello deberemos comprender el concepto de remapeo de números. Utilizaremos una gráfica para modificar en tiempo real una lista de valores de cotas que dará alturas diferentes a cada punto de la superficie.

Definimos una malla de puntos idéntica a la de E6 Paraboloide Hiperbólico.

Tomamos un Domain y lo definimos entre dos valores, p.ej. 0 y 1,5, que van a representar la altura mínima y máxima que alcanzará nuestra superficie. Dividimos ese domain con un range que genera tantos valores como puntos haya en nuestra malla, esto es, medimos con list length cuántos puntos hay en nuestra lista de puntos, y le restamos 1 para enchufarlo a la N del rango.

Mapeamos los valores del rango a un intervalo entre 0 y 1 con Remap. Estos valores se introducen en Graph Mapper para ser modificados por una función. A la salida del Graph Mapper se devuelven a su dominio original con un segundo Remap. Finalmente, estos valores se introducen en la coordenada Z de nuestro componente punto.

Conectamos la salida de puntoXYZ a Surface Grid. La cantidad U de puntos de la entrada es la N del rango + 1.

domain, list length, remap numbers, graph mapper, surface grid

1. Malla base de puntos. 2. Afectar la coordenada Z con una gráfica.3. Dibujar la superficie.

1. Malla base de puntos.

2. Afectar la coordenada Z con una gráfica.

3. Dibujar la superficie.

E07

Banco Lungomare, fuente: www.escofet.com Mercado de Santa Caterina, fuente: www.wikipedia.org

gestión de listas y condicionalesC


Guillermo Ramírez

p0134

ordenar una lista

01. objetivos

02. conceptos clave

03. procedimiento

- comprender que una lista es una sucesión de elementos, en la que el orden y la posición de los mismos dentro de ella es relevante

Vamos a ordenar los puntos de división de una circunferencia según la distancia a un punto interior a la misma. Primero, dibujamos una circunferencia y la dividimos con Divide curve y dibujamos los índices de cada uno de los puntos con Point list. Y segundo, colocamos un punto dentro de ella con un parámetro de punto, haciendo click con el botón derecho y luego yendo a Set one Point.

Medimos la distancia entre la lista de puntos que salen de divide curve (A) y el punto que hemos elegido previamente (B)

sort list, point list

A. Dibujar unos puntos (lista que vamos a ordenar) B. Parámetro con el que ordenar la listaC. Ordenar la listaD. Visualización del resultado

A. Dibujar unos puntos (lista que vamos a ordenar)

B. Parámetro con el que ordenar la lista

E08

Ordenamos la lista de distancias con Sort List. En la entrada y salida K, devuelve cualquier lista numérica ordenada de menor a mayor. Y en la entrada y salida A, ordena cualquier lista, de la misma longitud que la de K, en el mismo orden que ha utilizado para K. Se pueden ordenar tantas listas como se quiera de este modo, haciendo clic con el botón derecho en Input Manager ...

C. Ordenar la lista

Para visualizar el resultado, primero dibujamos los puntos ordenados con Point List, pero, esta vez, los escalamos para que no coincidan con los del apartado 1; y, segundo, dibujamos líneas a puntos entre el punto interior y los de la circunfrerencia con Dash Pattern .

D. Visualización del resultado


Guillermo Ramírez

p0135

triangulación de una cercha

01. objetivos

02. conceptos clave

03. procedimiento

- repasar la noción de lista como sucesión ordenada de elementos- conocer cómo se desfasan listas según índices

Tomamos como curva base de la cercha una curva dibujada en Rhino y almacenada en un parámetro de curva en Grasshopper mediante Set one Curve, haciendo click con el botón derecho en el mismo.

Los puntos base de la cercha los obtenemos dividiendo la curva base mediante Divide distance y los puntos de coronación, tomando las coordenadas X e Y de estos puntos (con point decompose) y la coordenada Z, un slider.

shift list

1. Curva base 2. Puntos para ejes3. Ejes de la estructura4. Dibujo de la estructura

1. Cordón inferior

2. Puntos para ejes

E09

- Ejes de los montantes: líneas entre puntos base y de coronación.- Diagonales: líneas entre puntos base y coronación desfasados una posición.- Cordón inferior: líneas entre puntos base y ellos mismos desfasados una posición.- Cordón superior: líneas entre puntos de coronación y ellos mismos desfasado una posición.Desfasamos tanto la lista de puntos base como la de coronación con shift list.

3. Ejes de la estructura

Finalmente, dibujamos la estructura, con un pipe de todas los ejes, almacenados en un parámetro de curva.

4. Dibujo de la estructura


Guillermo Ramírez

p0136

malla bidimensional de pilares

01. objetivos

02. conceptos clave

03. procedimiento

- introducirse en y comparar las nociones de colecciones numéricas en Grasshopper con series y dominios- comprender el modo de correspondencia de datos entre listas en Grasshopper

Definimos las dimensiones de la malla con sliders, que devuelven números dentro de un intervalo. Se pueden modificar deslizando el puntero en la barrra.

En primer lugar, utilizaremos una serie y, en segundo lugar, un dominio y así las podemos comparar. Una serie es una colección de “C” números reales que comienza en un número inicial “S” con un salto de “N” entre cada uno de ellos. Un dominio es un tramo continuo de la recta real definido por unos límites. Para hacer discreto ese tramo continuo, dividiéndolo en partes y obteniendo como resultado una colección de números reales, utilizamos un rango.

series, domain, range, point, cross reference, line

1. Definición de parámetros de la estructura.

2. Coordenadas de los puntos de la estructura. Colecciones numéricas.

E10

1. Definición de parámetros de la estructura.2. Coordenadas de los puntos de la estructura. Colecciones numéricas.3. Dibujo de los puntos base y de coronación.4 y 5. Dibujo de los ejes y de los pilares

Tomamos, bien la salida de la serie, bien la del rango como entradas de las coordenadas X e Y. En los puntos base, la coordenada Z será 0 y en los de coronación, definimos la altura con otro slider.

3. Dibujo de los puntos base y de coronación.

Los ejes de los pilares son líneas entre dos puntos. Los puntos de inicio de las líneas (A) serán los puntos base y los de final (B), los de coronación. Para dibujar unos pilares circulares, utilizamos pipe con las líneas como curvas base (C) y otro slider como radio de los pilares.

4 y 5. Dibujo de los ejes y de los pilares


Guillermo Ramírez

p0137

triangulación de la malla de pilares

01. objetivos

02. conceptos clave

03. procedimiento

- conocer cómo se eliminan elementos de una lista, aplicándolo a la triangulación de la malla de pilares del ejercicio E03- comprender la relación entre los índices de una lista y los valores númericos de los dominios y las series

En el caso hipotético de que quisiéramos triangular la malla de pilares del ejercicio E03, tendríamos que desfasar la lista de puntos de coronación y dibujar una línea entre los puntos base y los puntos de coronación desfasados. Si dibujáramos las diagonales resultantes, tendríamos una estructura como la de la primera imagen de la derecha.

shift list, cull pattern, cull index

4. Dibujar los ejes de los pilares5. Eliminar las diagonales sobrantes(Los apartados anteriores y posterior corresponden al ejercicio EO3)

4. Dibujar los ejes de los pilares

E11

Para deshacernos de la diagonal que atraviesa la planta, utilizaremos las herramientas de eliminación de elementos de una lista: Cull. Utilizando, por ejemplo, Cull Nth (también podríamos hacerlo, con otros valores, con Cull Index) tendremos que averiguar la relación numérica que existe entre los parámetros de la estructura y la frecuencia con que se da esa diagonal que nos sobra. Dependiendo si hemos dibujado la malla de pilares con series o con dominios y rangos, la frecuencia de esa diagonal estará relacionada, respectivamente, con la cantidad de copias (C) de la serie que da lugar a los puntos de la malla de la estructura, o con el número de divisiones del dominio (N) más una unidad.

5. Eliminar las diagonales sobrantes


Guillermo Ramírez

p0138

malla de pilares con patio

01. objetivos

02. conceptos clave

03. procedimiento

- elaborar un algoritmo sencillo, que consiste en eliminar los pilares del ejercicio E03 en un entorno de un radio determinado para fabricar un patio en la estructura - trabajar con sentencias condicionales: comparadores y valores booleanos

Los datos que definen el patio son las distancias de un punto de origen al resto de puntos base de los pilares. Todos los puntos que estén en un entorno que determinemos alrededor de ese punto, deberán eliminarse.

La condición que vamos a establecer para eliminar pilares de ese entorno es que la distancia entre el punto de origen sea mayor (Larger than) que un valor.

booleanos, true, false, larger than, dispatch

1. Datos de filtrado 2. Evaluación esos datos3. Extraer valores booleanos4. Filtrado de los datos iniciales(Para terminar el ejercicio, dibujamos el patio con la cubierta)

1. Datos de filtrado

2. Evaluación de los datos de filtrado

E12

La pregunta de cuáles de todas las distancias son mayores que el número del slider de “entorno” devuelve una lista de valores booleanos (verdadero y falso) de la misma longitud que la lista de distancias.

3. Extraer valores booleanos

Para quedarnos con los valores que corresponden con True (verdadero), utilizamos la herramienta Dispatch, que toma una lista L, la coteja con otra lista de valores booleanos y devuelve en A los ítemoes de L que coinciden con un valor True en P y en B, los que coinciden con False. La lista L que tomamos será la de los ejes de los pilaresEl último apartado es un ejercicio geométrico que se sale ligeramente del objetivo principal del ejercicio. Lo hacemos simplemente para dejar dibujado adecuadamente el patio.

4. Filtrado de los datos iniciales

geometríaD


Guillermo Ramírez

p0140

brújula

01. objetivos

02. conceptos clave

03. procedimiento

- definir geométricamente puntos con coordenadas XYZ y polares- utilizar funciones de una variable para cálculos matemáticos- dibujar vectores a partir de dos puntos y visualizarlos- entender cómo se miden ángulos en Grasshopper

Las coordenadas de los puntos XYZ son las coordenadas en el sistema de coordenadas universal. Las coordenadas para los puntos polares son: plano origen del punto (P), ángulo en radianes en ese plano (xy), ángulo en radianes en el plano normal (z) y distancia radial al origen (d). Utilizamos una función de una variable f(x) para pasar de grados a radianes

Conectamos las salidas numéricas de las coordenadas a las entradas correspondientes de los componentes de puntos. Utilizamos un punto XYZ como origen del dibujo y otro punto polar para definir el extremo del vector.

function, f(x), point polar, vector display, angle

1. Establecer las coordenadas de los puntos 2. Dibujo de los puntos3. Definir los vectores y visualizarlos4. Medir el ángulo entre esos vectores

1. Establecer las coordenadas de los puntos

2. Dibujo de los puntos

E13

Utilizamos el componente de vector dos puntos, entre el punto XYZ y el punto polar. Como los vectores son entidades geométricas definidas por una longitud y una dirección, no tienen una visualización, así que utilizamos “vector display” para dibujar dicho vector V utilizando el origen como punto de ancla A.

3. Fabricar vectores y visualizarlos

Computamos el ángulo entre el vector anterior y un vector unitario en el eje X. Como resultado, obtendremos dos ángulos: el convexo (A) y el reflejo (B).

4. Medir el ángulo entre esos vectores


Guillermo Ramírez

p0141

vector solar

01. objetivos

02. conceptos clave

03. procedimiento

El objetivo es definir un vector “solar” en coordenadas polares y compararlo con el vector normal a una superficie. Colorearemos puntos sobre la superficie según su exposición a la radiación solar.

Con el componente Point Polar dibujamos un punto que gira en torno al Origen. Uniendo con Line el Origen y el punto polar, obtenemos la dirección de nuestro sencillo vector solar, con vector display podemos visualizarlo. Si tratamos a la línea como si fuera un vector, Grasshopper no tiene problemas porque la convierte automáticamente.

Referenciamos con dos Curve (icono de borde hexagonal) dos curvas dibujadas en Rhino, y conectamos ambos a la entrada S de un componente Loft. Con Divide Surface dividimos la superficie en puntos en los cuales conocemos el vector normal (salida N del Divide Surface). Un Flatten en las salidas N y P del Divide Surface nos libra de las sublistas.

point polar, loft, angle, divide surface, flatten, gradient, preview

1. Definir un vector en coordenadas polares.2. Dibujar y dividir una superficie.3. Comparar vectores y asignar color.4. Visualizar.

1. Definir un vector en coordenadas polares.

2. Dibujar y dividir la superficie.

E14

Con un Angle comparamos los vectores normales (salida N del Divide Surface) con el vector solar (salida L de Line). A estos valores de ángulo les tenemos que asignar un color. Esto se consigue con Gradient. Con la paleta de Gradient definimos el espacio de color que vamos a hacer corresponder con los valores de ángulo, este espacio queda determinado entre los límites L0 y L1. Un ángulo

3. Comparar vectores y asignar color.

El último componente, Preview, sirve para colorear: le asigna color a geometría. Nuestra información de color sale del Gradient, y la geometría a colorear son todos los puntos que salen del flatten de la salida P de Surface Divide.

de 0 radianes será rojo, uno de Pi será rojo también, y, en Pi/2, cuando los los vectores sean perpendiculares, la luz será rasante y le asignaremos el color verde.

4. Visualizar.


Guillermo Ramírez

p0142

subdivisión y triangulación de una superficie

01. objetivos

02. conceptos clave

03. procedimiento

El objetivo de este ejercicio es subdividir una superficie alabeada en porciones menores utilizando sus coordenadas locales U y V, y luego trazar las diagonales de cada cuadrado. Las sublistas nos ahorrarán mucho trabajo.

Para dibujar una superficie alabeada, en Rhino dibujaremos dos curvas. Las referenciamos en un componente Curve (de icono hexagonal) y conectamos ambas a la entrada S de un componente Loft. Deben estar dibujadas en el mismo sentido ya que si una ha sido dibujada de izquierda a derecha y la otra al revés, aparecerá un giro extraño en nuestra superficie.

Como si de un domain2 se tratara, conectamos el Loft a la entrada de divide domain2. Grasshopper interpreta directamente que queremos trabajar sobre el dominio bidimensional de coordenadas locales de la superficie. Asignamos sliders a U y V. Conectamos la salida del divide domain2 a Isotrim (subsurface) que ahora sí, divide la superficie con el patrón del domain2. Con Brep Components explotamos cada subsuperficie en sus vértices, aristas y caras.

loft, divide domain2, isotrim, list item, sublista

1. Dibujar la superficie. 2. Dividir la superficie en partes.3. Seleccionar los vértices de cada parte.4. Dibujar las diagonales.

1. Dibujar la superficie.

2. Dividir la superficie en partes.

E15

Con cuatro list item diferentes podemos seleccionar los vértices 0, 1, 2 y 3 de cada subsuperficie. Como Isotrim ha hecho una sublista de cada cara, un list item que nos escoja el elemento 0, cogerá la misma esquina de todas las subsuperficies a la vez, ahorrándonos trabajo.

3. Selecionar los vértices de cada parte.

Ya sólo queda unir cada pareja opuesta de puntos con una linea para dibujar las diagonales. Como seguimos trabajando dentro de la estructura de sublistas, basta unir el punto 0 con el 2 para que Line nos dibuje las diagonales 0-2 de todas las caras. Repetir el proceso para las diagonales 1-3. Podemos añadir grosor a las barras si utilizamos un Pipe.

4. Dibujar las diagonales


Guillermo Ramírez

p0143

panelización de una superficie

01. objetivos

02. conceptos clave

03. procedimiento

En este ejercicio definimos una superficie a partir de una curva que se repite en vertical y aprendemos a replicar una geometría sobre ella.

El primer paso es dibujar una curva en Rhino y almacenarla en un componente Curve en Grasshopper. Luego la copiaremos en vertical con Move. Move necesita un vector para funcionar así que conectamos a la entrada T de Move un Unit Z: un vector unitario. Conectamos una serie a la entrada F del vector para generar varios vectores verticales y así tener múltiples copias.de la curva.

Conectando la lista de curvas a un Loft obtenemos la superficie que buscamos. Luego necesitamos dividir el domain2 del loft. La entrada U del divide domain2 tiene que ser el mismo valor que el slider que regula la C de la serie, menos uno, si queremos que las subdividiones en altura coincidan con la posición de las curvas replicadas. Extraemos los dominios unidimensionales del dominio bidimensional con Domain2 Components puesto que más tarde nos hará falta.

move, domain2 components, bounding box, surface morph.

1. Repetir una curva N veces en Z2. Superficie a partir de las curvas y subdivisión.3. Surface Morph.

1. Repetir una Curva N veces en Z.

2. Superficie a partir de las curvas y subdivisión.

E16

Surface Morph toma una geometría contenida en una caja de referencia y la replica sobre una superficie deformándola de acuerdo a las coordenadas locales de la superficie. Dibujamos un objeto a replicar en Rhino, y lo almacenamos en un componente Geometry de icono hexagonal. En este caso, el objeto dibujado será una lama inclinada. Aplicamos Bounding Box a la lama para generar la caja de referencia.

3. Surface Morph

Surface Morph es un componente con mútiples entradas: en la G debemos enchufar el cable que lleva la geometría (la lama) a replicar, en la R la caja de referencia de Bounding Box que contiene la lama, en la S la superficie sobre la cual vamos a replicar la lama, en la U y V, los dominios que vienen del Domain2 Components, y por último, la W, en la que conectaremos un Slider que regulará la altura de las réplicas sobre la superficie.

modelado paramétricoE


Guillermo Ramírez

p0145

Monumento a los judíos de Europa asesinados, Peter Eisenman

01. objetivos

02. conceptos clave

04. procedimiento

03. programa

- parametrizar un diseño de un proyecto real- aplicar la noción de dominio a medidas concretas- subdividir una región del espacio con planos- tomar medidas pseudoaleatorias para elaborar “prototipos” de diseños

1.1. Extraer los dominios de cada una de las direcciones: dibujamos el sólido capaz que contiene a la parcela (bounding box), que será una caja plana, y extraemos sus esquinas con (box corners). Los dominios de la parcela, tanto en el eje X como en Y son las coordenadas X e Y de dichas esquinas.

domain, plane, intersection, containment, duplicate data, jitter

1. Dibujar los puntos de origen de las losas 2. Dibujar las losas con las medidas de los datos de partida en esos puntos

Datos de partida:- parcela: dibujamos en Rhino un polígono similar a la planta del solar- anchura de losas: 2.38 m.- fondo de losas: 0.95 m.- número de losas: 371

“El Monumento a los judíos de Europa asesinados (...) es un monumento que recuerda en Berlín a los judíos víctimas del holocausto.Fue diseñado por el arquitecto Peter Eisenman y por la ingeniería Buro Happold. Se trata de un campo inclinado de 19000 metros cuadrados cubierto por una rejilla cuadriculada en la que están situadas 2711 estelas o losas de hormigón. Estas losas tienen unas dimensiones de 2.38m de largo y 0.95m de ancho, y varían en cuanto a su altura, desde los 0.2 m a los 4.8m. (...)”Fuente: www.es.wikipedia.org

1. Dibujar los puntos de origen de las losas

NOTA: En este ejercicio, se han reducido las medidas reales de superficie total y número de losas para dar lugar a un archivo menos pesado.

E17

Monumento a los judios de Europa asesinados, vista de satélite. Fuente: Google Earth.

Monumento a los judios de Europa asesinados, vista general. Fuente: www.wikipedia.org.


Guillermo Ramírez

p0146

1.2. Dibujar los planos de corte para cada dirección: en primer lugar, necesitamos los puntos de origen de esos planos, que estarán contenidos en los bordes del sólido que encierra a la parcela. Tomamos los dominios de cada eje y los dividimos en números reales con un rango. El número de subdivisiones del del dominio (la N del rango) puede ser la longitud lineal del sólido capaz en cada eje (la resta numérica de las coordenadas de los bordes del dominio para cada dirección) entre la medida de la losa más un paso. En segundo lugar, una vez obtenidos los puntos, sólo tenemos que tomar los vectores unitarios adecuados para dibujar los planos en cada dirección: para los planos en la dirección X, los vectores serán los unitarios en los ejes Y y Z; y para los planos en la dirección Y, los vectores serán los unitarios en los ejes X y Z. El último plano para fabricar las intersecciones que darán lugar a los puntos será el plano universal XY.

1.3 . Puntos de losas: una vez obtenidos los planos, tan sólo nos queda fabricar las intersecciones con Intersect plane|plane|plane (3PX). Para quedarnos solamente con los puntos interiores de la parcela, utilizamos la herramienta Point Containment, que comprueba si una lista de puntos (P) están o no en el interior de una curva cerrada C y devuelve en R la relación entre el punto y la curva (0 si está sobre la curva, 1 si está dentro de la curva y 2 si está fuera de la curva de región) y en P’ la proyección de dicha lista de puntos sobre el plano que contiene a la curva plana cerrada. Sólo nos queda quedarnos con los puntos coincidentes con los valores “2” de la salida R de Point Containment con una igualdad y Dispatch. Por último, nos quedaremos con los valores de la salida A de Dispatch.

2.1. Rectángulo base de losas: Dibujamos una lista de rectángulos, tomando como puntos de origen P los puntos de origen fabricados en el apartado anterior y dimensiones X e Y, el ancho y fondo de la losa de los datos de partida respectivamente; la entrada de R corresponde al radio de redondeo de las esquinas, en este caso, es igual a cero (el valor por defecto).2.2. Número exacto de losas: con Random reduce eliminamos ítemes de la lista L de forma pseudoaleatoria. Eliminaremos tantos elementos R hasta llegar a la contidad de losas de los datos de partida

2. Dibujar las losas con las medidas de los datos de partida


Guillermo Ramírez

p0147

2.3 Extrusión de los rectángulos base de las losas : Para reproducir el paisaje del monumento, tomamos unas alturas de losas prefijadas, como medidas de unos prefabricados, que distribuiremos de un modo aparentemente aleatorio, utilizando la herramienta jitter. Necesitamos tantos valores de extrusióncomo losas, para ello repetimos la lista de alturas de losas con “duplicate data”, que repite los valores de una lista D N veces. Jitter desordena los elementos de una lista, modificando sus índices pseudoaleatoriamente.Para terminar, tapamos la extrusión con cap holes.


Guillermo Ramírez

p0148

estructura de la Mediateca de Sendai, Toyo ItoE1801. objetivos

02. conceptos clave

03. procedimiento

El objetivo de este ejercicio es realizar un repaso de los conceptos generales aprendidos en todos los ejercicios anteriores. Dibujaremos un sólo pilar triangulado de la mediateca de Sendai, de Toyo Ito. Comenzaremos con un punto, luego un círculo, luego una colección de círculos transformados (copiados, escalados, rotados) y finalmente resolveremos su triangulación.

El primer paso es dibujar el centro desde el cual se va a referenciar toda la definición: será un punto dibujado en Rhino y almacenado en un componente Point de icono hexagonal. Conectamos el punto a la entrada P de un Circle, con radio gobernado por un slider que llamaremos Radio Maestro. El siguiente paso es replicar el círculo en altura. Lo haremos como hicimos en E16, con una serie y un vector Unit Z conectados a un Move. Le daremos el nombre H al slider que se conecta con la N de la serie, y el nombre Cantidad al slider que se conecta con la C de la serie. Este último slider es muy importante y lo vamos a conectar a muchas partes de nuestra definición posteriormente.

move, scale, rotate, center, random, jitter.

1. Dibujar un círculo y replicarlo en altura.2. Desplazar aleatoriamente en el plano XY.3. Escalar aleatoriamente respecto de cada centro.4. Rotar cada anillo..5. Dibujar la superficie y dividirla.6. Explotar las subsuperficies y seleccionar sus vértices.7. Triangular y dar grosor a las barras.

1. Dibujar un círculo y replicarlo en altura.

Ahora definiremos otro vector de traslación para un nuevo Move, pero en este caso con Vector XYZ. Generaremos valores aleatorios con Random para la X, comprendidos entre -1.1 y 1.1, y los barajaremos con Jitter para introducirlos en la Y. Este uso combinado de Random y Jitter nos evita tener que hacer dos

2. Desplazar aleatoriamente en el plano XY.


Guillermo Ramírez

p0149

estructura de la Mediateca de Sendai, Toyo ItoE18

colecciones independientes de valores aleatorios. Simplemente generamos una colección y la barajamos. Es importante que haya números aleatorios positivos y negativos para permitir desplazamiento en cualquier dirección del plano XY. Los números aleatorios deben ser tantos como anillos haya. Esto se logra conectando el slider inicial Cantidad a la N del Random.

Debemos agrandar y encoger cada círculo de manera diferente y cada uno desde su propio centro. Con un componente Center conectado a nuestra última colección de círculos, hallamos los centros de cada uno de ellos. Estos centros conectarán con la entrada C de un componente Scale. Los factores de escala F serán números aleatorios (generados como en el paso anterior) comprendidos entre e. 0.7 y el 1.2 aproximadamente. Como en el paso anterior, debe haber tantos valores aleatorios como anillos haya. Esto se logra conectando el slider inicial Cantidad a la N del Random.

3. Escalar aleatoriamente respecto de cada centro.

Este paso es el más complicado de comprender. Es más fácil dibujar hasta el paso 5 y luego pararse y retroceder. Nuestra estrategia es generar una piel con un loft, luego subdividirla y triangularla como hicimos en E15, pero para que los triángulos de la subdivisión sean isósceles y no rectángulos debemos retorcer los anillos. Retorcer significa rotar el primer anillo un ángulo α, el segundo un ángulo 2α y así sucesivamente. Sacamos un Slider que llamamos Divs (divisiones). Este slider cobrará mayor sentido en el paso 5. Pasamos el valor de Divs por una función que divide Pi/Divs. Este resultado es el incremento de ángulo de rotación que resulta de un anillo al siguiente y que debemos conectar a la entrada N de una Serie. La C de la serie es el slider inicial Cantidad. La serie va conectada a la A de Rotate. Si el anillo se define como un polígono de cantidad de lados igual a Divs, entonces y sólo entonces tendremos una triangulación en la que los vértices de los anillos poligonales superiores caen sobre los puntos medios de los anillos poligonales inferiores (uf!!). Si no nos queremos creer esto, podemos probar valores de ángulo cualesquiera para la A para entender cómo se comporta la estructura.

4. Rotar cada anillo.


Guillermo Ramírez

p0150

estructura de la Mediateca de Sendai, Toyo ItoE18

En el paso 5 empezaremos a ver los efectos del retorcimiento que planeamos en el punto 4. Este paso es análogo al E15. Enchufamos los anillos rotados al Loft, y marcamos dentro de Loft Options loft la opción UNIFORM. Esto hará que el loft se ajuste con precisión a los anillos. Dividimos el loft con Divide Domain2, cuya U es el valor de Cantidad - 1, y cuya V viene del slider Divs. Aquí observamos que el slider Divs regula la cantidad de lados del anillo. Con Isotrim aplicamos el patrón de corte del Divide Domain2 a nuestra superficie generando las subsuperficies.

En el paso 5 continuamos con lo aprendido en E15. La técnica es idéntica. Explotamos las subsuperficies con Brep Components y seleccionamos los vértices con List Item haciendo uso de la estructura de sublistas para ahorrarnos trabajo. Con tres list item que seleccionen el vértice 1, 2 y 3 de cada subsuperficie debería valernos.

5. Dibujar la superficie y dividirla.

6. Explotar las subsuperficies y seleccionar los vértices.

Este paso es muy sencillo. Con tres Line diferentes, unimos la salida del List Item1 con el 3, la del 1 con el 2, y la del 2 con el 3. Luego le damos grosor a las barras con un Pipe como hicimos en E15.

7. Triangular y dar grosor a las barras.


Guillermo Ramírez

p0151

listas de datos que queremos evaluar

resultado de la

evaluación

(lista de valores booleanos)

filtrado de los datos iniciales a través del resultado

evaluación de los datos

(generalmente comparación)


Guillermo Ramírez

p0152

- sucesión de datos (se colocan “uno detrás de otro”)

- el orden es relevante ({A, B, C} no es igual que {C, B, A})

- la longitud está determinada (“list length”)

- se accede a los datos refiriendose al índice dentro de la sucesión

- el primer objeto tiene el índice cero

- están formateadas con un tipo de dato (o números, o puntos, etc., no todos a la vez)

índice

índice dato

0 1 2 3 4 5 6 7 8 9

1er ÍTEM

longitud

último ÍTEM

dato dato datodato dato datodato dato dato dato

Estructura de datos: listas


Guillermo Ramírez

p0153

- list item

- list length

- shift list

- sort list

Este componente sirve para extraer ítemes concretos de listas. Tiene tres entradas: L para la(s) lista(s) de la(s) que queremos extraer el item, I para el índice que queremos obtener y W (wrap).

Operaciones con listas

Este componente nos da la cantidad de ítemes de una lista y tiene tan sólo una entrada: L para la(s) lista(s) de la(s) que queremos extraer la longitud.

Este componente desplaza el orden de los elementos de la lista las posiciones que indiquemos. Tiene tre sólo una entrada: L para la(s) lista(s) de la(s), S para la cantidad de posiciones que queremos desplazar y W si queremos dar la vuelta a la lista.

Sort list ordena listas. Las entradas y salidas K orde-nan la lista de menor a mayor y A sirve para ordenar otra lista con el mismo patrón con los que se ha orde-nado K.


Guillermo Ramírez

p0154

- reverse list Este componente modifica el orden de una lista, colocándo los ítemes en el orden inverso de la lista. Tiene tan sólo una entrada: L para la(s) lista(s) que queremos invertir.

- split list

Split list divide una lista en dos a partir de un índice. Tiene dos entradas: L para la(s) lista(s) e i para el índice desde el que dividir la lista. Las salidas son A y B, las dos listas resultado.

- sub list Sub list extrae los ítemes de una lista dentro de un(os) intervalo(s). L es la entrada para la(s) lista(s) e I para el dominio. Las salidas son L para la lista re-sultado e I para los índices.

manual de ejercicios de grashopper nivel 2


02. geometría de mallas y deformación de superficies

01. Grasshopper como herramienta de visualización de datos

03. gestión de listas: estructura de árbol de datos

04. modelado con algoritmos evolutivos

índice

aplicado al diseño algorítmico de arquitecturamanual de ejercicios de grasshopper nivel 2

manual de grasshopper nivel I aplicado al diseño de arquitecturapor miguel vidal calvet y guillermo ramírez camarero

edición Noviembre 2010grasshopper v0.8.002

p0157

manual de grasshopper nivel 2 Miguel Vidal

Guillermo Ramírez

Grasshopper como herramienta de visualización de datos: lectura y edición de datos externos

01

p0158


Guillermo Ramírezlectura de datos externos y gestión de cadenas de caracteres

01. objetivos

02. conceptos clave

03. procedimiento

- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

xxxxxxxxxxxxxxxxxxxxxxxx

x, x, x, x, x

1. xxxxxxxxxxxxxxxxx2. xxxxxxxxxxxxxxxx3. xxxxxxxxxxxxxx4. xxxxxxxxxxxxxxxxx

1. xxxxxxxxxxxxxxxxxxx

E01

p0159


Guillermo Ramírezvisualización y etiquetado de datos

01. objetivos

02. conceptos clave

03. procedimiento



x, x, x, x, x



E02

p0160


Guillermo Ramírez

geometría de mallas y deformación de superficies

02

p0161


Guillermo Ramírezsubdivisión de superficie no homogénea

01. objetivos

02. conceptos clave

03. procedimiento



x, x, x, x, x



E03

p0162


Guillermo Ramírezdeformación de superficie

01. objetivos

02. conceptos clave

03. procedimiento



x, x, x, x, x



E04

p0163


Guillermo Ramírezmallas

01. objetivos

02. conceptos clave

03. procedimiento



x, x, x, x, x



E05

p0164


Guillermo Ramírez

gestión de listas: estructura de árbol de datos03

p0165


Guillermo Ramírez

Estructura de datos: árboles de Grasshoper

En Grasshopper, las listas datos se orde-nan, acumulativamente, con una estruc-tura ramificada.

Fuente: Grasshopper Primer for version 0.6.0007

rama

rama

rama

rama

rama

índice dato

p0166


Guillermo Ramírez

Visualización de estructura de árbol en Grasshoper

Para visuali-zar la estruc-tura de una lista, utiliza-mos el com-ponente pa-ram viewer. Podemos es-coger entre una vista tex-tual, por de-fecto, y una vista gráfica, “draw tree” (abajo).

Paths nú-mero de ra-mas que hay.

{ 0 ; 0 ; 0 } ruta de la rama.

N número de ítemes en cada rama. representación

de esta lista

p0167


Guillermo Ramírez

- tree branch

- tree item

Con este componente extrae-mos ramas de una estructura de árbol. Tiene dos entradas: T para la(s) estructura(s) de árbol de la que queremos extraer una rama, P para el ruta de la rama que queremos obtener. Las ru-tas de las ramas son cadenas de caracteres.

Con este componente extrae-mos ítemes dentro de ramas de una estructura de árbol. Tiene cuatro entradas: T para la(s) estructura(s) de árbol de la que queremos extraer una rama, P para el ruta de la rama que que-remos obtener, i para el índice del item y W para wrap. Los índices de listas son enteros.

Se pueden realizar las mismas operaciones que con listas, pero con distintos componentes y, sobre todo, diferente sintaxis.

Operaciones sobre estructura de árboles

p0168


Guillermo Ramírez

- flatten tree

- graft tree

“Flatten tree” convierte una es-tructura de diversas ramas en otra de una sola rama. Es decir hace de una lista de sublistas una lista única. En D insertamos la estructura y con P decidimos la ruta en la que colocamos esa lista.

Con “graft tree” hacemos la op-eración contraria: convertimos en una rama cada item de la lista original.

p0169


Guillermo Ramírez

- explode tree

- merge/merge03/merge multiple

Extrae las ramas de una es-tructura de árbol una por una. Se añaden salidas haciendo click con el botón derecho en “output manage”.

Merge combina las listas de estructuras de árbol, teniendo en cuenta las rutas de dichas estructuras de árbol, dando lugar a una lista de listas con las rutas correspondientes.

p0170


Guillermo Ramírezrepetición de números en dos listas

01. objetivos

02. conceptos clave

03. procedimiento

- entender el concepto de ramas en estructura de árbol de datos en Grassshopper, para ello, trataremos de saber la cantidad de veces que se repiten los números de una lista en otra

Convertimos la primera lista de números en una lista de listas con un ítem en cada una de ellas, es decir, fabricamos una estructura de ramas para cada ítme de la lista con Graft tree.

Para hallar las repeticiones de la primera lista en la segunda, utilizamos un componente de igualdad y nos quedamos sólo con las coincidencias de True con Dispatch.

Finalmente, contamos cuántos elementos hay en la lista de salida de Dispatch, con List length: las ramas que no tengan ningún elemento contarán como cero. Por último, deshacemos la estructura de ramas con Flatten tree para compararlo con la lista A.

graft tree, flatten tree

1. Estructura de árbol en la lista A2. Repeticiones de la lista A en la lista B3. Deshacer la estructura de árbol de la lista A

1. Estructura de árbol en la lista A

2. Repeticiones de la lista A en la lista B

3. Deshacer la estructura de árbol de la lista A

E06

p0171


Guillermo Ramírezconvento de las Teresianas, Gaudí

01. objetivos

02. conceptos clave

03. procedimiento

- trabajar con los conceptos de ramas en estructura de árbol de datos- entender cómo funciona Loft con varias listas de curvas

Dibujamos unas curvas catenarias entre dos listas de puntos A y B con la misma serie para las coordenadas Y, separadas una distancia para las coordenadas X, una longitud L proveniente de un slider y una dirección de gravedad con vector unitario Z.

Dibujamos una superficie de transición Loft a lo largo de la lista de curvas del apartado anterior y la extruímos a lo largo del eje Z.

En primer lugar, desfasamos las curvas iniciales con Offset Curve para tener las curvas de sección planas de las vigas. Para dibujar, la superficie plana de los nervios, utilizamos un Loft de esas dos listas de curvas, pero primero debemos tener la misma estructura en las listas, una lista para cada curva, para ello aplicamos un Graft Tree a la lista de curvas iniciales (comparar las listas en la captura de pantalla en la siguiente página). En segundo lugar, nos queda extruir las superficies del Loft para tener la estructura definitiva.

catenary, offset curve, loft, graft tree

1. Curvas de sección de los arcos2. Piel de cubierta3. Estructura de cubierta

1. Curvas de sección de los arcos

2. Piel de cubierta

3. Estructura de cubierta

E07

Colegio Teresiano, Barcelona, Antonio Gaudí.

p0172


Guillermo Ramírez

p0173


Guillermo Ramírezgusano paramétrico

01. objetivos

02. conceptos clave

03. procedimiento

- practicar las nociones de estructura de árbol de datos, dibujando una estructura desfasada


offset, flatten, param viewer, tree branch



E08

p0174


Guillermo Ramírez

p0175


Guillermo Ramírezlamas no homogéneas en superficie

01. objetivos

02. conceptos clave

03. procedimiento

- entender cómo se tratan independientemente partes de geometría con estructura de árbol de datos, para ello fabricaremos una fachada de lamas con distribución heterogénea de la superficie del ejercicio E08- repasar conceptos de topología y análisis de curvas

Para dividir las curvas base en tramos, utilizamos la herramienta Shatter Curve, que trabaja con el parámetro t de las curvas. Antes de nada, para que cada curva tome un “canal de información” independiente, utilizamos Graft Tree. Luego tomamos la curva, la desfasamos hacia adentro con Offset Curve. Para hallar el parámetro t de división de las curvas, buscamos con Curve Closest Point el punto más cercano a las curvas de los puntos de división del ejercicio anterior, que nos devuelve el parámetro t de dichas curvas que buscábamos.

2.1. Desplazamos cada tramo de curva a lo largo del eje Z: para dibujar una fachada “prototipo”, tomamos valores de vectores de desplazamiento pseudoaleatorios. En primer lugar, como en el apartado anterior, aplicamos Graft Tree a la lista de tramos de curvas, para que cada una de ellas esté en una ruta de datos distinta. Para tener valores distintos de desplazamiento, pero contenidos dentro del valor de la altura del recinto superior, limitamos esos valores con un dominio. A continuación, subidivimos ese dominio con un rango. El valor de subdivisiones N está definido por valores de un Random, limitado por un dominio R de cantidad de huecos mínimo y máximo, el número de valores N será de tantos valores como ítemes tengamos en las listas (tomamos la longitud de lista del Param Viewer) y también necesitaremos una semilla S diferente para cada uno de ellos, por ejemplo, tomamos de una serie.

graft tree, flatten tree, shatter curve, offset, evaluate curve

1. Dividir las curvas en tramos2. Mallar cada tramo de fachada independientemente3. Dibujar la estructura de fachada

1. Dividir las curvas en tramos

2. Mallar cada tramo de fachada independientemente

E09

p0176


Guillermo Ramírez

Para dibujar una estructura de fachada formada por perfiles rectangulares, necesitamos dibujar un rectángulo en cada punto base de las curvas superiores orientado según el vector normal a la curva en ese punto. Para ello, evaluamos las curvas con Evaluate curve en cada uno de los parámetros t que hemos obtenido antes. A continuación, tomamos la salida P (puntos en la curva) y T (vectores paralelos de la curva) para dibujar los planos que tomaremos como orígenes para los rectángulos de sección de la estructura. Los valores de X e Y del rectángulo de sección son los dominios de extensión para cada dirección. Para terminar, sólo nos queda extruir estos rectángulos.

3. Dibujar la estructura de fachada

2.2. Fabricar las superficies planas de las lamas: necesitamos desfasar las curvas base con Offset Curve y además tener las listas de curvas con la misma estructura de datos, para poder, por ejemplo, utilizar una superficie de transición con Loft. Para ello, aplicamos un Graft Tree a las curvas base, puesto que con Offset Curve, se hace una lista diferente para cada curva.

2.3. Extruir las superficies planas de las lamas: tan sólo tenemos que aplicar un Extrude a lo largo del vector Z.

p0177


Guillermo RamírezVoronoi masterplan

01. objetivos

02. conceptos clave

03. procedimiento

- comprender la relación entre las rutas de la estructura de árbol y la geometría que se va empleando en Grasshopper y modificarlas con graph mapper- trabajar con diferentes elementos geométricos independientemente

Para dibujar una planta, tomamos la triangulación plana de Voronoi, para lo cual necesitaremos una colección de puntos (P).1.1. Coordenadas de puntos: dibujaremos con dos colecciones numéricas pseudoaleatorias (Random) tanto para las coordenadas X como para las Y. Además, limitaremos la extensión del Voronoi con una Interval Box en B.1.2 Diagramas de Voronoi: tomamos las entradas anteriores para dibujar los polígonos de Voronoi.1.3 Desechamos algunos polígonos: para tener algunos vacíos en la planta, aplicamos Random Reduce a la salida de Voronoi, que elimina R elementos de una lista L, de un modo pseudoaleatorio, tomando una semilla S.

2.1. Puntos perímetro base: dividimos los perímetros de cada polígono de Voronoi con Divide Curve, para ello, antes debemos tener cada polígono en una rama distinta con Graft Tree.2.2. Puntos perímetro de coronación: damos unos valores pseudoaleatorios, limitados por una altura mínima y máxima con un dominio a la cota Z de cada uno de los puntos de perímetro base.2.3. Superficies para los cerramientos: uniendo los puntos base con los de coronación con una colección de líneas, podemos utilizar éstas como curvas de sección de una superficide de transición Loft.

graft tree, voronoi, param viewer, path mapper

1. Planta. Diagramas de Voronoi2. Cerramientos3. Cubiertas

1. Planta. Diagramas de Voronoi

2. Cerramientos

E10

p0178


Guillermo Ramírez

3.1. Puntos interiores base: dividimos los perímetros de cada polígono de Voronoi con Surface Divide, para ello, antes debemos convertir los polígonos en superficie con un parámetro de Surface.3.2. Puntos interiores de coronación: damos unos valores pseudoaleatorios, limitados por una altura mínima y máxima con un dominio a la cota Z de cada uno de los puntos interiores base.3.3. Cubiertas: podemos utilizar una malla de Delaunay con los puntos de coronación. Antes debemos fusionar las dos listas de los puntos de perímetro de coronación con los puntos interiores de coronación con Merge. En Grasshopper, la operación de subdivisión de geometría, como la del apartado 3.1, da lugar a nuevas subramas en cada polígono para cada columna de puntos de subdivisión, las rutas de las dos lístas de puntos de coronación, no van a coincidir. Antes de nada, a efectos de claridad, eliminamos índices de rutas sobrantes con Simplify Tree. Ahora, para hacer corresponder las dos listas de puntos con las mismas rutas para cada polígono, debemos deshacer la ruta que ha generado Surface Divide para cada columna con Path mapper. Dicho componente trabaja con operaciones léxicas sobre las rutas de la estructura de árbol. Cualquier estructura léxica en la parte izquierda del componente será sustituída por la de la derecha. En nuestro caso, los índices de la primera columna “A” equivalen a cada uno de los polígonos, la segunda columna, con todo ceros, es residual de algún componente y la tercera columna “B”, son cada una de las columnas de puntos de cada polígono, la última es también residual. La tercera columna es la que debemos eliminar en nuestra operación léxica.

3. Cubiertas

p0179


Guillermo Ramírezintersección de visuales

01. objetivos

02. conceptos clave

03. procedimiento



x, x, x, x, x



E11

p0180


Guillermo Ramírez

modelado con algoritmos evolutivos04

manual básico de scripting

con RhinoCommon en Grasshopper

aplicado al diseño generativo de arquitectura

lenguajes C# y python

miguel vidal calvetwww.frikearq.com

edición Octubre 2011

notas previas

Este documento no pretende ser una referencia para quien quiera aprender a programar.

Este manual es un pequeño compendio de ejercicios, a modo de cuaderno de apuntes, destinado a quien quiera introducirse en la elaboración de scripts para generar diseños. Necesariamente, se pasará por encima de los conceptos básicos de la programación para empezar a escribir código que entienda la máquina. Será una pasada rápida, pero suficiente para ponerse a escribir códgio lo antes posible de una manera solvente.

Esto NO es un manual de programación

Esto SÍ es un manual de scripting para Rhino elaborado por diseñadores para diseñadores

manual básico de scripting con Grasshopper en C# y pythonpor miguel vidal calvet y guillermo ramírez camarero

edición Julio 2011grasshopper v0.8.0010

A. Nociones básicas de programación

ANEXO 3. Glosario de términos

ANEXO 1. Estructura de RhinoCommon

ANEXO 2. Processing

B. RhinoCommon en Grasshopper

A.1. Introducción a la programación aplicado al diseño generativo B.1. Microejercicios de iniciación a C# y RhinoCommon

B.2. Ejemplos de aplicación

A.2. Tipos de datos, declaración y operaciones con variables

A.4. Funciones: abstracción

A.3. Claúsulas condicionales e Iteración

índice

ANEXOS

aplicado al diseño generativo de arquitectura

manual básico de scripting con Grasshopper en C# y python

01 Programación orientada a objetos.02 Interfaz de scripting en Grasshopper

03 Declaración de datos simples: enteros, decimales y booleanos. 04 Declaración de datos compuestos: cadenas de caracteres, listas, y es-tructura de árbol de datos.

07 Estructura de una Función08 Valor de una función: return

05 Cláusulas condicionales: cláusulas if ... else y switch.06 Estructuras terativas: bucles for y while.

E01 Dibujar cuatro puntos formando los vértices de un cuadradoE02 Dibujar cuatro puntos formando los vértices de un cuadrado a partir de un vértice inicial y un valor de ladoE03 Medir las distancias diagonales e imprimirlas en un panelE04 Introducir los puntos en una listaE05 Unir los puntos en diagonal con líneasE06 Dibujar un rectángulo a partir de esos puntos E07 Elaborar una función que fabrica un vectores entre dos puntosE08 Fabricar vectores a partir de los vértices y visualizarlos dándoles colorE09 Unir los vértices consecutivamente mediante líneasE10 Extraer los puntos medios de cada segmento de rectángulo y unirlos con líneas

B2.1 Pabellón temporal de la galería Serpentine del año 2002, Toyo Ito con Cecil Balmond

Programación y diseño generativo

A

manual de scripting con grasshopper Miguel Vidal

Guillermo Ramírez

p0185

introducción a la programación aplicada al diseño generativoA101. ¿C# o python? 03. ¿Qué es la programación orientada a objetos?

C# es un lenguaje de programación orientada a objetos basado en C y C++, es muy similar a Java, tiene una extensa y actualizada documentación y está construido por una plataforma muy extendida como .NET. Debido a esto, hacen que sea un lenguaje idóneo para dar los primeros pasos en los entornos de programación.

En cuanto a las similaridades, principalmente con Java, y también C++, hacen que sea sencillo entender y pasar fácilmente a otros entornos útiles para los diseñadores, sobre todo, Processing y Arduino, o también scripting con Maya. También puede ser un buen comienzo para más adelante adoptar con facilidad Python, que probablemente sea un lenguaje de programación estándar para desarrollar scripts en software de 3D y otros.

En cuanto a la documentación, desde un punto de vista meramente práctico, el hecho de estar respaldado por una plataforma potente como .NET (desarrollada por Microsoft), aseguran las actualizaciones y soporte del mismo. Para consultar la referencia, ir a:http://msdn.microsoft.com/en-us/library/kx37x362.aspx

La programación orientada a objetos es un paradigma de programación que usa objetos y sus interacciones para diseñar aplicaciones y programas informáticos.

Los objetos son entidades que tienen un determinado estado, comportamiento (método) e identidad:

El estado está compuesto de datos, será uno o varios atributos a los que se habrán asignado unos valores concretos. El comportamiento está definido por los métodos o mensajes a los que sabe responder dicho objeto, es decir, qué operaciones se pueden realizar con él. La identidad es una propiedad de un objeto que lo diferencia del resto, dicho con otras palabras, es su identificador (concepto análogo al de identificador de una variable o una constante).

Un objeto contiene toda la información que permite definirlo e identificarlo frente a otros objetos pertenecientes a otras clases e incluso frente a objetos de una misma clase, al poder tener valores bien diferenciados en sus atributos. A su vez, los objetos disponen de mecanismos de interacción llamados métodos, que favorecen la comunicación entre ellos. Esta comunicación favorece a su vez el cambio de estado en los propios objetos. Esta característica lleva a tratarlos como unidades indivisibles, en las que no se separa el estado y el comportamiento.

Fuente: wikipedia.org


Guillermo Ramírez

p0186

03. Interfaz de scripting en Grasshopper

Existen tres componentes de scripting en Grasshopper en los que se puede escribir código en otros tantos lenguajes: - C# Script - VB Script - Python Script

Para extraer estos componentes, ir a la pestaña de Math > Script.Los dos primeros componentes vienen cargados en la instalación de Grasshopper. En el momento de la edición de este manual, el componente de scripting con Python únicamente puede utilizarse con Rhino 5. Para instalarlo, visitar: http://www.food4rhino.com.

Para escribir código en estos componentes, hacer doble click en el cuerpo del mismo o bien click con el botón derecho y luego Edit source. Se abrirá una ventana en la que escribiremos nuestro código en donde se lee “// your code here”.

Edición del componente script

Podemos trabajar con tantas variables como queramos dentro del código que escribamos y también podemos utilizar las entradas del componente para introducir datos de la definición de Grasshopper o de archivos de Rhino. Además, podremos también tener salidas de datos a nuestra elección.

Para modificar las entradas de datos, haremos click con el botón con el botón derecho e ir a Input manager ... Además, éstas deben ser formateadas del modo adecuado para trabajar con ellas en nuestro componente. Hablaremos de ello en el siguiente capítulo. A continuación, unas imágenes con los pasos de este proceso

Para modificar salidas de datos, hacer click con el botón con el botón derecho e ir a Output manager ... Estos datos están formateados por el componente como Object y Grasshopper lo entiende como Generic Data (dato genérico), así que no es necesario darle ningún formato específico.

Entradas y salidas de variables del componente script

escribiremos el código a partir de esta línea


Guillermo Ramírez

p0187

La salida out

La función Print

La salida out del componente script tiene dos funciones:

- devolver los posibles errores del código - imprimir los datos que deseemos

Esta salida sería como la consola de cualquier entorno de programación. Para visualizar cualquiera de ambos casos anteriores, conectaremos un panel.

La función Print escribe cadenas de caractares (ver tipos de datos compuestos), es decir, texto en la salida out del componente script.

Esta función nos será muy útil para ir comprobando la validez de nuestro código, como veremos a lo largo del manual.

NOTA: A partir de ahora, todo el texto con la apariencia del párrafo inmediatamente superior, corresponderá a código que introduciremos en el componente de script a partir de la línea donde se lee el texto “//your code here”, como antes se ha comentado.

Print(“hola, cocacola);

C# python


Guillermo Ramírez

p0188

Comentarios en el código

Otro asunto que también va a sernos muy útil para hacer nuestros scripts es hacer comentarios dentro del código. Los comentarios son texto que forma parte del código, pero que la máquina va a obviar cuando lo está leyendo.

Esto nos puede servir para anotar aspectos relevantes del código o asuntos que son importantes recordar y también para ordenarlo. Esto nos servirá no sólo para no perdernos nosotros mismos sino para posibles futuras segundas o terceras personas que puedan acceder a él.

Existen dos maneras de comentar el código

- comentario de una sola línea: cualquier texto que escribamos en una línea a partir de los caracteres de barra “//” quedará comentado.

- comentario multilínea: cualesquiera línea o líneas de texto entre los caracteres de apertura “/*” y de cierrre “*/” quedarán comentadas.

//la función print sirve para imprimir textoPrint(“hola, cocacola);

/*código de prueba escrito como primer ejercicio del manual de scripting de Frikearq :)*/

//la función print sirve para imprimir textoPrint(“hola, cocacola);

El intérprete lee el código línea a línea de arriba a abajo y de izquierda a derecha. Para que el intérprete cambie de línea, es necesario añadir “;” al final de cada una de ellas, para que entienda que el código continúa en la siguiente línea.

C#

C#

python

python


Guillermo Ramírez

p0189

tipos de datos, declaración y operaciones con variablesA205. Tipos de datos primitivos

Tipos de datos primitivos que más vamos a utilizar y sus identificadores

tipo de dato nombre (en inglés) identificadornúmero entero integer int

número decimal double precision floating-point number

double

valor booleano (verdadero o falso)

boolean value (true o false) bool

caracter character char

Y un dato compuesto para empezar ...

tipo de dato nombre (en inglés) identificadorcadena de caracteres string string

NOTA: Una cadena de caracteres, o sea, texto, es un tipo de dato, como el nombre indica, compuesto de una sucesión de caracteres. El motivo por el cual lo mostramos en este punto, es que la salida out imprime cadena de caracteres, esto quiere decir, que para que devuelva cualquier dato hay que convertirlo previamente a string. Esto nos será útil para ir mostrando en pantalla lo que vayamos haciendo.

C# python


Guillermo Ramírez

p0190

Existen funciones para convertir datos de un tipo a otro.

int entero = 1;double decimal = 2.5;bool verdadero = true;

//debemos convertir los datos a cadena de caracteres para poder imprimirlos en pantallaPrint(entero.ToString());Print(decimal.ToString());Print(verdadero.ToString());

Algunas conversiones de datos habituales

Convertir ...

... a entero Convert.ToInt32(valor) o (int)valor... a decimal Convert.ToDouble(valor) o (double)valor

... a booleano Convert.ToBoolean(valor)... a cadena de caracteres valor .ToString()

NOTA: En programación, sigue una lógica binaria, de verdadero o falso, en la que al valor numérico entero “0” se le asigna el valor booleano “falso” (false) y al valor numérico entero “1” se le asigna el valor booleano “verdadero” (true).

C# python


Guillermo Ramírez

p0191

04. Variables

Una variable es un nombre que se asigna a una cantidad conocida o desconocida de información para poder trabajar con este nombre, independientemente de la información que representa. La mayor parte del trabajo que vamos a realizar con nuestros scripts lo haremos a través de variables.

Para trabajar con variables es necesario inicializarlas según el tipo de dato que representa. El esquema básico que sigue el lenguaje de programación C# es el siguiente:

identificador de variable

(el tipo de dato que va a contener esa variable)

nombre de variable

(cualquier nombre excepto los reservados)

asignación valor

int a = 12 ;



nombre de variable

asignación valor

int a = 12 ;

Inicialización de variables

Asignación de valor a variables

Inicialización y asignación en la misma línea

int a = 12 ;

C# python


Guillermo Ramírez

p0192

07. Datos compuestos

Antes de comenzar con este apartado, recordamos que para declarar, inicializar y asignar valor a variables de datos compuestos, seguiremos el mismo esquema que habíamos visto en el apartado de variables, pero con una excepción: debemos instanciarlos.


(el tipo de dato que va a contener esa

variable)

tipo de dato

(en qué formato vamos a almacenar

los datos)

nombre de

variable(el que

queramos)

asignación=

instanciación(new seguido del

tipo de dato)

valor

Listas

En programación, las listas son sucesiones ordenadas de elementos. Para declarar e instanciar una lista, seguimos el esquema anterior:

La lista que acabamos de instanciar está vacía, para añadir elementos dentro de ella, utilizamos la función .Add.

Finalmente, igualamos la salida con la lista que hemos fabricado.

Para extraer un ítem, utilizamos el siguiente método, que también lo podemos asignar a otra salida del componente, después de haberla añadido con Ouput manager..

List<Point3d> listaPts = new List<Point3d>();

listaPts.Add(new Point3d(1, 1, 1)); listaPts.Add(new Point3d(2, 2, 2)); listaPts.Add(new Point3d(3, 3, 3));

B = listaPts[1];

A = listaPts;

C# python


Guillermo Ramírez

p0193

Matrices

Point3d[] puntos = new Point3d[3];

puntos[0] = new Point3d(1, 1, 1); puntos[1] = new Point3d(2, 2, 2); puntos[2] = new Point3d(3, 3, 3);

A = puntos; B = puntos[2];

El trabajo con matrices es diferente al de listas. Para inicializar una matriz, es necesario darle un tamaño y no se pueden añadir elementos, sino que es necesario igualar cada item a un valor.

C#


Guillermo Ramírez

p0194

Estructura de árbol de datos

DataTree<Point3d> puntos = new DataTree<Point3d>();

puntos.Add(new Point3d(1, 1, 1)); puntos.Add(new Point3d(2, 2, 2)); puntos.Add(new Point3d(3, 3, 3));

A = puntos; B = puntos.Branch(0)[0];

DataTree<Point3d> puntos = new DataTree<Point3d>(); GH_Path ruta = new GH_Path(2);

puntos.Add(new Point3d(1, 1, 1), ruta); puntos.Add(new Point3d(2, 2, 2), ruta); puntos.Add(new Point3d(3, 3, 3), ruta);

A = puntos; B = puntos.Branch(ruta)[0];

También podemos asignar rutas en las que queremos almacenar la estructura de árbol de datos, que declararemos con el tipo GH_Path. GH_Path se construye con números enteros. Las rutas o paths son nombres a las que se le asignan a la estructura de árbol de datos.

C# python


Guillermo Ramírez

p0195

inicialización

comprobación

declaración

actualización (según un rango

que establezcamos)

07. Iteración

A3

for(inicialización; comprobación; rango de actualizacion){ declaración;}

for inicializacion in range(comienzo, rango): declaración

si es verdadero

si es falso

C# python


Guillermo Ramírez

p0196

A4

C# python

08. Funciones: abstracción

Las funciones son subrutinas incluidas dentro de un programa más grande y que nos permite resolver una tarea específica. Las funciones son útiles para desarrollar tareas que se van a repetir dentro del programa principal y para, de esta manera, modular el código en apartados pequeños. Las funciones en C# devuelven un único valor, que se asigna con return.

Dicha subrutina, cuando es llamada dentro del código principal, hace que la lectura de ese código se detenga y se dirija a ejecutar el código de la subrutina. En ciertos lenguajes de programación, como C#, las funciones son subrutinas que devuelven un valor. En los componentes de Grasshopper, tendremos que añadir el código de la función en el apartado de “//<Custom additional code>“.

Nuestra primera función, que fabricará vectores a partir de dos puntos, se llamará Vector2Puntos, y la podremos llamar desde nuestro código como una función más de C# o RhnoCommon.

TIPO QUE DEVUELVE(en caso de que devuelvaalgún valor)

OPERACIONES DE LA FUNCIÓN

VALOR QUE QUEREMOS QUE DEVUELVAreturn

NOMBRE

{

}

Estructura de una función

;

(

)

PARÁMETROS DE LA FUNCIÓN(que hay que declarar en este punto)

RhnoCommon en Grasshopper

B

microejercicios de creación de geometría con RhinoCommon

B.1


Guillermo Ramírez

p0199

E01dibujar cuatro puntos formando los vértices de un cuadrado

private void RunScript(object x, object y, ref object A, ref object B, ref object C, ref object D) { //declaramos las variables double lado; // valor numérico decimal Point3d vertice0; //punto3d (una clase de Rhino) Point3d vertice1; Point3d vertice2; Point3d vertice3; // asignamos valores a las variables lado = 20; // para los puntos, invocamos la clase Point3d con new. El valor de las coordenadas X e Y del verticeOrigen (propiedad de una clase) y le sumamos el valor de lado vertice0 = new Point3d(0, 0, 0); vertice1 = new Point3d(0, lado, 0); vertice2 = new Point3d(lado, lado, 0); vertice3 = new Point3d(0, lado, 0); // asignamos cada uno de los puntos a una salida del componente A = vertice0; B = vertice1; C = vertice2; D = vertice3; }

# en primer lugar, tenemos que importar el módulo de geometría de Rhinoimport Rhino.Geometry as rg# con “as” asignamos un “apodo” a ese módolu, de esta manera, cada vez que llamamos a una clase de ese módulo, no tendremos que escribir todo su nombre, sino sólo ese “apodo”

# declaramos y asignamos la variable de ladolado = 20# declaramos y asignamos las variables de puntosvertice0 = rg.Point3d.Originvertice1 = rg.Point3d(lado, 0, 0)vertice2 = rg.Point3d(lado, lado, 0)vertice3 = rg.Point3d(0, lado, 0)# asignamos un vértice a cada una de las salidas del componentea = vertice0b = vertice1c = vertice2d = vertice3

01. objetivos

02. conceptos clave

03. procedimiento

- trabajar con variables- construir puntos con RhinoCommon

double, Point3d

C#python


Guillermo Ramírez

p0200

E02dibujar cuatro puntos formando los vértices de un cuadrado a partir de un vértice inicial y un valor de lado

Tomamos dos variables exteriores al componente de script: - una primera, que toma valores numéricos de un slider. Deberemos hacer click con el botón derecho en la entrada y luego “Type hint” para que lo entienda como un dato de tipo numérico decimal (double). - otra segunda, a la que llamamos verticeInicial, que toma el valor del vértice incial a partir del cual posicionamos el resto de puntos y que inicializamos como el tipo Point3d de Rhino.

private void RunScript(double lado, Point3d verticeOrigen, ref object A, ref object B, ref object C, ref object D){ //declaramos las variables como punto3d (Point3d una clase de Rhino) en una única línea Point3d vertice1,vertice2,vertice3; // asignamos un valor a la variable invocando la clase Point3d con new El valor de las coordenadas X e Y del punto(propiedad de una clase) y le sumamos el valor de lado vertice1 = new Point3d(verticeOrigen.X + lado, verticeOrigen.Y, 0); vertice2 = new Point3d(verticeOrigen.X + lado, verticeOrigen.Y + lado, 0); vertice3 = new Point3d(verticeOrigen.X, verticeOrigen.Y + lado, 0); // asignamos cada uno de los puntos a una salida A = verticeOrigen; B = vertice1; C = vertice2; D = vertice3; }

# en primer lugar, tenemos que importar el módulo de geometría de Rhinoimport Rhino.Geometry as rg # con “as” asignamos un “apodo” cada vez que llamamos a una clase de ese módulo

# declaramos y asignamos las variables de puntosvertice0 = rg.Point3d.Originvertice1 = rg.Point3d(lado, 0, 0)vertice2 = rg.Point3d(lado, lado, 0)vertice3 = rg.Point3d(0, lado, 0)# asignamos un vértice a cada una de las salidas del componentea = vertice0b = vertice1c = vertice2d = vertice3

01. objetivos

02. conceptos clave

03. procedimiento

- acceder a propiedades de clases- trabajar con input de datos externos al componente

double, Point3d

C# python


Guillermo Ramírez

p0201

E03medir las distancias diagonales e imprimirlas en un panel

01. objetivos

02. conceptos clave

03. procedimiento

- imprimir texto por la salida out del componente de script y utilizar cadenas de caracteres- utilizar funciones matemáticas en el código y los métodos de Math- trabajar con estructuras condicionales

double, Point3d, Distance, Print, if, else

Primero, calculamos la distancia algebraicomente y, luego, medimos la distancia con el método Distance de Pointd3d. Por último, comprobamos que ambas coinciden.

//// añadimos el código del ejercicio anterior //// // declaramos y asignamos las variables double diagAlg1 = Math.Sqrt(Math.Pow((vertice2.X-verticeOrigen.X), 2)+Math.Pow((vertice2.Y-verticeOrigen.Y),2));//Math.Sqrt() es una raíz cuadrada double diagAlg2 = Math.Sqrt(Math.Pow((vertice3.X - vertice1.X), 2) + Math.Pow((vertice3.Y - vertice1.Y), 2)); double diagPt1 = verticeOrigen.DistanceTo(vertice2); double diagPt2 = vertice1.DistanceTo(vertice3); // Math.Round redondea a los decimales que queramos diagAlg1 = Math.Round(diagAlg1, 2); diagAlg2 = Math.Round(diagAlg2, 2); diagPt1 = Math.Round(diagPt1, 2); diagPt2 = Math.Round(diagPt2, 2);// estructura condicional if((Math.Round(diagAlg1, 2) == Math.Round(diagPt1, 2)) && (Math.Round(diagAlg2, 2) == Math.Round(diagPt2, 2))) { Print(“guay!”); } else { Print(“horror!”); }

### añadimos, primero, el código del ejercicio anterior #### importamos los módulos que vamos a utilizarimport math# declaramos y asignamos las variables de las diagonalesdiagAlg1 = math.sqrt(math.pow((vertice2.X-vertice0.X), 2)+ math.pow((vertice2.Y-vertice0.Y) ,2)) #math.sqrt() es una raíz cuadradadiagAlg2 = math.sqrt(math.pow((vertice3.X - vertice1.X), 2) + math.pow((vertice3.Y - vertice1.Y), 2));diagPt1 = vertice0.DistanceTo(vertice2)diagPt2 = vertice1.DistanceTo(vertice3)

# round redondea el valor a tantos decimales como queramosdiagAlg1 = round(diagAlg1, 2)diagAlg2 = round(diagAlg2, 2)diagPt1 = round(diagPt1, 2)diagPt2 = round(diagPt2, 2)

# estructura condicionalif((round(diagAlg1, 2) == round(diagPt1, 2)) & (round(diagAlg2, 2) == round(diagPt2, 2))): print(“guay!”)else: print(“horror!”)

C# python


Guillermo Ramírez

p0202

E04introducir los puntos en una lista

01. objetivos

02. conceptos clave

03. procedimiento

- aprender a declarar, crear y añadir valores a una lista

List, new, Add

private void RunScript(double lado, Point3d verticeO-rigen, ref object A) { //declaramos las variables como punto3d (una clase de Rhino) Point3d vertice1 = new Point3d(verticeOrigen.X + lado, verticeOrigen.Y, 0); Point3d vertice2 = new Point3d(verticeOrigen.X + lado, verticeOrigen.Y + lado, 0); Point3d vertice3 = new Point3d(verticeOrigen.X, verticeOrigen.Y + lado, 0); // declaramos una lista de puntos llamada “vertices” List<Point3d> vertices; // utilizamos el constructor predeterminado para crear una lista de de puntos con una capacidad de 0 vertices = new List<Point3d>(); //añadimos valores a la lista en orden vertices.Add(verticeOrigen); vertices.Add(vertice1); vertices.Add(vertice2); vertices.Add(vertice3); // asignamos la lista a una salida A = vertices; }

# importamos los módulos que vamos a utilizarimport mathimport Rhino.Geometry as rg

# declaramos y asignamos las variables de puntosvertice0 = rg.Point3d.Originvertice1 = rg.Point3d(lado, 0, 0)vertice2 = rg.Point3d(lado, lado, 0)vertice3 = rg.Point3d(0, lado, 0)

# declaramos una lista a la que nombramos “vertices”vertices = []

# añadimos a los puntos anteriormente crados a esa lista de puntosvertices.append(vertice0)vertices.append(vertice1)vertices.append(vertice2)vertices.append(vertice3)

a = vertices

C# python


Guillermo Ramírez

p0203

E0501. objetivos

02. conceptos clave

03. procedimiento

C# python

- aprender a fabricar vectores, planos y rectángulos

Plane, Vector3d, Rectangle3d

//// utilizamos el código del ejercicio anterior, añadiendo una nueva salida, a la que llamamos “R” //////

// para fabricar un rectángulo, necesitaremos un plano y dos números decimales para el ancho y el alto Rectangle3d rec; // podemos fabricar un plano de distintas maneras, pero vamos a hacerlo a partir de un punto base y dos vectores Plane planoRec; Point3d ptoOrigenPlano = vertices[0]; // podemos declarar la variable y asignarle valor en la misma linea Vector3d vecXPlano = new Vector3d();// para construir un vector necesitamos sus coordenadas XYZ // sobreescribimos las propiedades X, Y y Z del vector vecXPlano.X = vertices[1].X - vertices[0].X; vecXPlano.Y = vertices[1].Y - vertices[0].Y; vecXPlano.Z = vertices[1].Z - vertices[0].Z; // también podemos declarar y construir el vector en la misma línea Vector3d vecYPlano = new Vector3d(vertices[3].X - vertices[0].X, vertices[3].Y - vertices[0].Y, vertices[3].Z - vertices[0].Z); planoRec = new Plane(ptoOrigenPlano, vecXPlano, vecYPlano); // ancho y alto: serán la misma medida, un lado double ladoRec = vertices[0].DistanceTo(vertices[1]); rec = new Rectangle3d(planoRec, ladoRec, ladoRec); R = rec;

### utilizamos el mismo código del ejercicio anterior, añadiendo una nueva salida, a la que llamamos “R” ###

# para fabricar un rectángulo,necesitaremos, en primer lugar, un plano y, en segundo lugar, dos números decimales para el ancho y el alto.## PLANO: se define a partir de un punto y dos vectoresptoOrigenPlano = vertices[0] # punto de origen planovecXPlano = rg.Vector3d.Unset # para definir los vectores, podemos, primero declaramos el vector como unset (“no definido”) y luego pasamos las variables X, Y, ZvecXPlano.X = vertices[1].X - vertices[0].XvecXPlano.Y = vertices[1].Y - vertices[0].YvecXPlano.Z = vertices[1].Z - vertices[0].Z## o también podemos declarar y asignar el valor al vector en la misma líneavecYPlano = rg.Vector3d(vertices[3].X - vertices[0].X, vertices[3].Y - vertices[0].Y, vertices[3].Z - vertices[0].Z)

planoRec = rg.Plane(ptoOrigenPlano, vecXPlano, vecYPlano)

## ANCHO y ALTO: este caso, serán la misma medida, un ladoladoRec = vertices[0].DistanceTo(vertices[1])

rec = rg.Rectangle3d(planoRec, ladoRec, ladoRec)#rectánguloR = rec # salida de datos

dibujar un rectángulo a partir de esos puntos


Guillermo Ramírez

p0204

E06extraer los puntos medios y tercios de los segmentos del rectángulo anteriormente creado

01. objetivos

02. conceptos clave

03. procedimiento

- aprender cómo trabaja un bucle for- acceder a a métodos de curvas

for, List, List item, Add

//// utilizamos el mismo código que en el ejercicio anterior E05 con nuevas salidas en el componente, una para los puntos medios y otra para los puntos tercios, a las que llamamos PM y PT respectivamente //// // definimos listas para los puntos medios y tercios List<Point3d> ptosMedios = new List<Point3d>(); List<Point3d> ptosTercios = new List<Point3d>(); // no existe ningún método en la clase Rectangle3d de Rhino para poder acceder a sus segmentos. Para ello, debemos, primero, convertir el rectángulo en polilínea, con el que sí podremos trabajar con los segmentos Polyline pol = rec.ToPolyline(); // bucle para extraer los puntos medios y tercios for(int i = 0; i < pol.SegmentCount; i++) { ptosMedios.Add(pol.SegmentAt(i).PointAt(0.5)); ptosTercios.Add(pol.SegmentAt(i).PointAt(0.333333)); // .SegmentAt() es el método con el que accedemos a las coordenadas locales de una curva para obtener un punto. Una línea está definida localmente en un dominio entre 0 y 1. El punto medio estará en 0.5 y el tercio en 0.333. } PM = ptosMedios; PT = ptosTercios;

### utilizamos el mismo código que en el ejercicio anterior E05 con nuevas salidas en el componente, una para los puntos medios y otra para los puntos tercios, a las que llamamos PM y PT #### definimos listas para los puntos medios y terciosptosMedios =[]ptosTercios = []# no existe ningún método en la clase Rectangle3d de Rhino para poder acceder a sus segmentos. Para ello, debemos, primero, convertir el rectángulo en polilínea, con el que sí podremos trabajar con los segmentosrec = rec.ToPolyline()# hacemos un bucle iterativo para unir puntos consectivamente. Es necesario indentado el códigofor i in range(0, rec.SegmentCount): # . SegmentCount es el método que nos devuelve el número de segmentos de la polilínea ptosMedios.append(rec.SegmentAt(i).PointAt(0.5))# .SegmentAt() es el método con el que accedemos a las coordenadas locales de una curva para obtener un punto. Una línea está definida localmente en un dominio entre 0 y 1. El punto medio estará en 0.5 y el tercio en 0.333.PM = ptosMediosPT = ptosTercios

C# python

Si quieremos llevar a cabo una tarea muy repetitiva o que es iterativa, utlizaremos una secuencia de bucle for. En este caso, se tratará de extraer los puntos medios de todos los segmentos del rectángulo que antes hemos creado.


Guillermo Ramírez

p0205

E07unir consecutivamente los puntos medios y tercios mediante líneas

01. objetivos

02. conceptos clave

03. procedimiento

- repasar la estructura iterativa del bucle for y la condicional if ... else- aprender a dibujar líneas

for, List, List item, Add

//// utilizamos el mismo código que en el ejercicio anterior con una nueva salida en el componente para las líneas,a la que llamamos “L” //// // declaración de lista de lineas para los lados List<Line> lineas = new List<Line>();

// bucle para unir los vértices consecutivamente for(int i = 0; i < ptosMedios.Count; i++) { // en primer lugar, añadimos una excepción para el último elemento de la lista if(i == ptosMedios.Count - 1) { lineas.Add(new Line(ptosMedios[i], ptosTercios[0])); } // si no colocáramos la excepción al comienzo, obtendríamos un error por acceso a un exceso de índices de lista else { lineas.Add(new Line(ptosMedios[i], ptosTercios[i + 1])); } } L = lineas; // salida de datos

### utilizamos el mismo código que en el ejercicio anterior con una nueva salida en el componente para las líneas, a la que llamamos “L” #### definimos una lista para las líneaslineas = []

# hacemos un bucle iterativo para unir puntos consectivamentefor i in range(0, len(ptosMedios)): # en primer lugar, añadimos una excepción para el último elemento de la lista if(i == len(ptosMedios) - 1): lineas.append(rg.Line(ptosMedios[i], ptosTercios[0])) # para añadir lineas en cada pasada del bucle, utilizamos el método append # si no colocáramos la excepción al comienzo, obtendríamos un error por acceso a un exceso de índices de lista else: lineas.append(rg.Line(ptosMedios[i], ptosTercios[i + 1]))

# salida de datosL = lineas

C# python


Guillermo Ramírez

p0206

E08extraer las intersecciones de las proyecciiones de líneas anteriormente creadas

01. objetivos

02. conceptos clave

03. procedimiento

- conocer cómo se trabaja con intersecciones de geometría

Intersection

# utilizamos el mismo código que en el ejercicio anterior con una nueva salida en el componente para los puntos de intersección, a la que llamamos I

# lista de interseccionesintersecciones = []for i in range (0, len(lineas)): if(i == len(lineas) - 1): hayInterseccion, a, b = rg.Intersect.Intersection.LineLine(lineas[i], lineas[0], 0, False) # hayInterseccion (boolean), a y b (double) son los valores que devuelve la función de intersección. El primero nos dice si existe o no esa intersección. Los otros dos son los valores de coordenadas locales de dicha intersección para la primera y la segunda línea respectivamente else: hayInterseccion, a, b = rg.Intersect.Intersection.LineLine(lineas[i], lineas[i + 1], 0, False) intersecciones.append(lineas[i].PointAt(a))

I = intersecciones# comprobamos que las intersecciones de líneas no son las de los tramos de los segmento de línea sino de las líneas como segmentos infinitos

//// utilizamos el mismo código que en el ejercicio anterior con una nueva salida a la que llamamos “I” //// List<Point3d> intersecciones = new List<Point3d>(); double a, b; for(int i = 0; i < lineas.Count; i++) { if(i == lineas.Count - 1){ bool hayInterseccion = Rhino.Geometry.Intersect.Intersection.LineLine(lineas[i], lineas[0], out a, out b, 0.0, false); if(hayInterseccion){ intersecciones.Add(lineas[i].PointAt(a)); } } else{ bool hayInterseccion = Rhino.Geometry.Intersect.Intersection.LineLine(lineas[i], lineas[i + 1], out a, out b, 0.0, false); if(hayInterseccion){ intersecciones.Add(lineas[i].PointAt(a)); } } } I = intersecciones;

C# python

Las intersecciones se encuentran en el espacio de nombres (Namespace) Intersect de Rhino. En este ejercicio, vamos a emplear el método para intersecciones de líneas, es decir, Intersect.Intersection.LineLine. Hay que tener en cuenta que el valor que devuelven las funciones de intersección es un booleano: verdadero (true) o falso (false) dependiendo de si hay intersección o no la hay. Vamos a aprender a continuación cómo extraer la geometría fruto de la intersección en los dos lenguajes.


Guillermo Ramírez

p0207

E09elaborar una función para fabricar vectores entre dos puntos

//<Custom additional code>

Vector3d Vector2Puntos(Point3d ptoA, Point3d ptoB) { Vector3d vec = new Vector3d(ptoB.X - ptoA.X, ptoB.Y - ptoA.Y, ptoB.Z - ptoA.Z); return vec; }

01. objetivos

02. conceptos clave

03. procedimiento

- aprender a elaborar funciones

function, Vector3d, Rectangle3d

Este código lo añadimos en el apartado “custom additional code” de tal manera que sirva para llamarlo en cualquier momento dentro del código principal.


Guillermo Ramírez

p0208

ejemplos de aplicación

B2


Guillermo Ramírez

p0210

pabellón de la Serpentine Gallery 2002, Toyo Ito con Cecil BalmondB2

Fotografía: © David Martin, fuente: flickr.com/photos/avidday

01. objetivos

02. conceptos clave

03. procedimiento

- crear geometría bidimensioneal y tridimensional con RhinoCommon- entender el funcionamiento de estructura de datos en programación orientada a objetos- aprender a trabajar con funciones para modular el código

List, DataTree, for, if

1. Dibujar el rectángulo inicial2. Extraer los puntos medios y tercios3. Dibujar las líneas de unión entre los puntos medios y tercios (líneas auxiliares)4. Dibujar las líneas de intersección con el rectángulo inicial (líneas de estructura)5. Dibujar un nuevo rectángulo a partir de puntos medios y tercios6. Introducir todas las funciones en un bucle iterativo7. Terminar el dibujo de la cubierta y las fachadas

5. Nuevo rectángulo4. Líneas de estructura (en la 1ª iteración son coincidentes con las líneas auxiliares)

7. Terminar de modelar la curbierta y fachadas *

6. Introducir todas las funciones en un bucle iterativo

2. Puntos medios y tercios del rectángulo inicial

3. Líneas auxiliares1. Rectángulo inicial

El pabellón temporal del año 2002 de la galería Serpentine, proyectado por Toyo Ito con Cecil Balmond, de Arup, se construye a partir de un algoritmo iterativo que dibuja la cubierta. Partiendo de un cuadrado, se van uniendo consecutivamente los puntos medios con los puntos tercios de sus segmentos.

* Este apartado del ejercicio, por su complejidad, se realizará con los componentes precargados de Grasshopper., por lo que no se explicará paso a paso en este manua.


Guillermo Ramírez

p0211

private void RunScript(double li, double cota, ref object rec_inic) { // declaración de variable Rectangle3d recInic;

// asignación de variable recInic = new Rectangle3d();

// inicialización de variable (refiriendose adecuadamente a sus constructores) recInic = new Rectangle3d(new Plane(new Point3d(0, 0, cota), Vector3d.XAxis, Vector3d.YAxis), new Interval(0, li), new Interval(0, li)); // el valor del lado del cuadrado es un slider (li) // asignar la variable construida a la salida rec_inic rec_inic = recInic; }

1. Dibujar el rectángulo inicial

Nuestro componente de script tendrá dos entradas conectadas a sliders: “li”, que define el lado del cuadrado inicial, y “cota”, que define la cota de arranque de la cubierta; y una salida: “rec_inic”:


Guillermo Ramírez

p0212

private void RunScript(double li, double cota, ref object rec_inic) { // declaración, asignación e inicialización de variable en la misma línea Rectangle3d recInic = new Rectangle3d(Plane.WorldXY, new Interval(0, li), new Interval(0, li)); // asignar la variable construida a la salida rec_inic rec_inic = recInic;

// lista contenedora de puntos List<Point3d> ptosMedios = new List<Point3d>(); List<Point3d> ptosTercios = new List<Point3d>();

//dividimos los segmentos // para ello, convertimos el rectángulo en polilínea con Rectangle3d.ToPolyline(), de tal manera que podemos acceder a cada uno de los segmentos con el método SegmentAt(indiceDeSegmento) for(int s = 0; s < recInic.ToPolyline().SegmentCount; s++) { Point3d ptoMedio = recInic.ToPolyline().SegmentAt(s).PointAt(0.5); ptosMedios.Add(ptoMedio);

Point3d ptoTercio = recInic.ToPolyline().SegmentAt(s).PointAt(0.333); ptosTercios.Add(ptoTercio) }

// devolvemos las variables por salidas diferentes ptos_medios = ptosMedios; ptos_tercios = ptosTercios; }

2. Extraer puntos medios y tercios


Guillermo Ramírez

p0213

3. Dibujar las líneas auxiliares

Para dibujar las líneas auxiliares, tendremos que unir el punto medio con el punto tercio del siguiente segmento. Tendremos que incluir una excepción para el último segmento del rectángulo, puesto que si dejamos que la lista vaya hasta el último elemento, el script dará un error. La excepción consistirá en que, cuando llegue al último índice, se una con el primer elemento y no con el siguiente.

private void RunScript(double li, ref object rec_inic, ref object ptos_medios, ref object ptos_tercios, ref object LA) { // declaración, asignación e inicialización de variable Rectangle3d recInic = new Rectangle3d(Plane.WorldXY, new Interval(0, li), new Interval(0, li)); rec_inic = recInic; // asignar la variable construida a la salida rec_inic

// listas contenedoras de puntos List<Point3d> ptosMedios = new List<Point3d>(); List<Point3d> ptosTercios = new List<Point3d>();

//lista contenedora de lineas List<Line> lineas = new List<Line>();

// convertimos el rectángulo a polilínea con la función .ToPolyline() al principio // y se la asignamos a una variable para no tener que llamarla luego tantas veces Polyline pol = recInic.ToPolyline();

//dividimos los segmentos for(int s = 0; s < pol.SegmentCount; s++) { //variables que se sobreescriben en cada pasada del bucle Point3d ptoMedio = new Point3d(); Point3d ptoTercio = new Point3d(); Line lPmPt = new Line();

//excepción en primer lugar para no caer en error con los índices de


Guillermo Ramírez

p0214

listas

if(s == pol.SegmentCount - 1) { ptoMedio = pol.SegmentAt(s).PointAt(0.5); ptoTercio = pol.SegmentAt(0).PointAt(0.333); lPmPt = new Line(ptoMedio, ptoTercio); }

else { ptoMedio = pol.SegmentAt(s).PointAt(0.5); ptoTercio = pol.SegmentAt(s + 1).PointAt(0.333); lPmPt = new Line(ptoMedio, ptoTercio); } //añadimos a las listas ptosMedios.Add(ptoMedio); ptosTercios.Add(ptoTercio); lineas.Add(lPmPt); }

// devolvemos las variables por salidas diferentes ptos_medios = ptosMedios; ptos_tercios = ptosTercios; LA = lineas; }


Guillermo Ramírez

p0215

4. Dibujar las líneas de estructura (intersección con el rectángulo inicial)

Hemos llamado “líneas de estructura” a aquellas que son la proyección de las líneas auxiliares sobre el rectángulo inicial. En la primera iteración, las líneas auxiliares coincidirán con las líneas de estructura, pero en las demás no.

Para dibujar estas líneas, primero hallaremos la intersección entre las líneas auxiliares con cada uno de los segmentos del rectángulo inicial. En Rhino, una intersección entre dos líneas se puede tomar como la intersección entre dos líneas similares pero de longitud infinita, así que no es necesario que se intersequen físicamente para que devuelvan los puntos de intersección.

//(...) todo el bloque de código del ejercicio anterior

//dividimos los segmentos for(int s = 0; s < pol.SegmentCount; s++) {//(...) todo el bloque de código del ejercicio anterior

// INTERSECCIÓN DE DOS LÍNEAS//lista de intersecciones List<Point3d> inter = new List<Point3d>(); // ruta para los datatree GH_Path ruta = new GH_Path(s); // fabricamos un nuevo bucle para las intersecciones con el rectángulo inicial for(int i = 0; i < pol.SegmentCount; i++) {

double a; // parametro t de la primera linea double b; // parametro t de la segunda linea

bool rc = Rhino.Geometry.Intersect.Intersection.LineLine(lPmPt, pol.SegmentAt(i), out a, out b, 0.0, false);

if(rc && (a >= 0 && b >= 0))// algunas de las intersecciones devolverá nulo o fuera de una linea (-1),


Guillermo Ramírez

p0216

así que colocamos esta excepción para no caer en error { inter.Add(pol.SegmentAt(i).PointAt(b)); } } //añadimos a la lista de puntos e intersecciones ptosInt.AddRange(inter, ruta); lineasEst.Add(new Line (inter[0], inter[1]), ruta); ///////////////////////////////////////////

//añadimos a las listas ptosMedios.Add(ptoMedio); ptosTercios.Add(ptoTercio); lineas.Add(lPmPt);

}

// devolvemos las variables por salidas diferentes ptos_medios = ptosMedios; ptos_tercios = ptosTercios; LA = lineas; PI = ptosInt; LE = lineasEst;


Guillermo Ramírez

p0217

5. Dibujar un rectángulo a partir de las líneas auxiliares anteriores

Rectangle3d RectanguloAPartirDeAuxiliares(List<Line> lineasAux) { Rectangle3d rec; //variable que vamos a devolver List<Point3d> verRec = new List<Point3d>(); //vertices del plano del rectangulo Plane pl; //plano del rectángulo // este bucle nos sirve para encontrar los vertices del rectangulo for (int j = 0; j < lineasAux.Count - 1; j++) { bool hayInterseccion; double paramLinea1, paramLinea2;

hayInterseccion = Rhino.Geometry.Intersect.Intersection.LineLine(lineasAux[j], lineasAux[j + 1],out paramLinea1, out paramLinea2, 0, false);

if(hayInterseccion && (paramLinea2 <= 1)) { //añadimos a la lista de intersecciones en el rectangulo verRec.Add(lineasAux[j + 1].PointAt(paramLinea2)); } } pl = new Plane(verRec[0], verRec[1], verRec[2]);//plano del rectangulo // construimos el nuevo rectangulo return rec = new Rectangle3d(pl, verRec[0].DistanceTo(verRec[1]), verRec[1].DistanceTo(verRec[2])); }

Elaboramos una función que devuelva un rectángulo a partir de una lista de líneas, que serán las líneas auxiliares. A dicha función la hemos llamado RectanguloAPartirDeAuxiliares.

El resutlatdo de esta función tiene que sobreescribirse en cada iteración.


Guillermo Ramírez

p0218

6. Introducimos todas las funciones en un bucle iterativo

Al introducir todas los pasos anteriores en sus correspondientes funciones y llamarlas desde un código principal, obtendremos la siguiente solución con cada función a continuación:

private void RunScript(double li, int nIt, ref object rec_inic, ref object lineas_auxiliares, ref object lineas_estructura) { // rectángulo inicial Rectangle3d recInic = new Rectangle3d(Plane.WorldXY, new Interval(0, li), new Interval(0, li));

DataTree<Line> lineasAux = new DataTree<Line>(); DataTree<Line> estructura = new DataTree<Line>();

Rectangle3d rec = recInic; for (int i = 0; i < nIt; i++) { //almacenamos cada paso del bucle en una rama diferente GH_Path ruta = new GH_Path(i);

List<Line> ln = FabricarDivisiones(rec); List<Line> est = LineasEstructura(recInic, ln);

lineasAux.AddRange(ln, ruta); estructura.AddRange(est, ruta); // rectangulo que se va a ir sobreescribiendo en cada paso del bucle rec = RectanguloAPartirDeAuxiliares(ln); } // salida de datos rec_inic = recInic; lineas_auxiliares = lineasAux; lineas_estructura = estructura; }


Guillermo Ramírez

p0219

FUNCIÓN PARA CONSTRUIR LAS LÍNEAS AUXILIARES

List<Line> LineasAuxiliares(Rectangle3d recInic) { // lista contenedora de puntos List<Point3d> ptosMedios = new List<Point3d>(); List<Point3d> ptosTercios = new List<Point3d>();

//lista contenedora de lineas List<Line> lineas = new List<Line>();

for(int s = 0; s < recInic.ToPolyline().SegmentCount; s++) { //variables que se sobreescriben en cada pasada del bucle Point3d ptoMedio = new Point3d(); Point3d ptoTercio = new Point3d(); Line lPmPt = new Line();

//excepción en primer lugar para no caer en error con los índices de listas if(s == recInic.ToPolyline().SegmentCount - 1) { ptoMedio = recInic.ToPolyline().SegmentAt(s).PointAt(0.5); ptoTercio = recInic.ToPolyline().SegmentAt(0).PointAt(0.333); lPmPt = new Line(ptoMedio, ptoTercio); }

else { ptoMedio = recInic.ToPolyline().SegmentAt(s).PointAt(0.5); ptoTercio = recInic.ToPolyline().SegmentAt(s + 1).PointAt(0.333); lPmPt = new Line(ptoMedio, ptoTercio); }

//añadimos a las listas ptosMedios.Add(ptoMedio); ptosTercios.Add(ptoTercio);


Guillermo Ramírez

p0220

lineas.Add(lPmPt); }

//devolvemos un valor de la función return lineas; }

FUNCIÓN PARA CONSTRUIR LAS LÍNEAS AUXILIARES

List<Line> LineasEstructura (Rectangle3d recInic, List<Line> div) { // declaramos e inicializamos la lista de líneas que vamos a querer devolver List<Line> lineas = new List<Line>();

for(int i = 0; i < div.Count; i++) { // fabricamos el plano Plane plano = new Plane(div[i].From, Vector2Points(div[i].From, div[i].To), Vector3d.ZAxis); // declaramos la lista de intersecciones List<Point3d> pi = new List<Point3d>();

//fabricamos la intersección con todos los segmentos del rectangulo for(int s = 0; s < recInic.ToPolyline().SegmentCount; s++) { Rhino.Geometry.Intersect.CurveIntersections ci = Rhino.Geometry.Intersect.Intersection.CurvePlane(recInic.ToPolyline().SegmentAt(s).ToNurbsCurve(), plano, 0.0);

//para no caer en error cuando no hay intersecciones, añadimos la excepción de que sólo añadimos los puntos cuando haya intersección if(ci != null)


Guillermo Ramírez

p0221

{ //añadimos los puntos for (int p = 0; p < ci.Count; p++) { pi.Add(ci[p].PointA); } } } //fabricamos la línea y la añadimos a la lista lineas.Add(new Line(pi[0], pi[1])); } return lineas; }

FUNCIÓN PARA CONSTRUIR UN RECTÁNGULO A PARTIR DE LAS LÍNEAS AUXILIARES

Rectangle3d RectanguloAPartirDeAuxiliares(List<Line> lineasAux) { Rectangle3d rec; //variable que vamos a devolver List<Point3d> verRec = new List<Point3d>(); //vertices del plano del rectangulo Plane pl; //plano del rectángulo // este bucle nos sirve para encontrar los vertices del rectangulo for (int j = 0; j < lineasAux.Count - 1; j++) { bool hayInterseccion; double paramLinea1, paramLinea2;

hayInterseccion = Rhino.Geometry.Intersect.Intersection.LineLine(lineasAux[j], lineasAux[j + 1], out paramLinea1, out paramLinea2, 0, false);


Guillermo Ramírez

p0222

if(hayInterseccion && (paramLinea2 <= 1)) { //añadimos a la lista de intersecciones en el rectangulo verRec.Add(lineasAux[j + 1].PointAt(paramLinea2)); } }

pl = new Plane(verRec[0], verRec[1], verRec[2]);//plano del rectangulo // construimos el nuevo rectangulo return rec = new Rectangle3d(pl, verRec[0].DistanceTo(verRec[1]), verRec[1].DistanceTo(verRec[2])); }

FUNCIÓN PARA CONSTRUIR UN VECTOR A PARTIR DE DOS PUNTOS

Vector3d Vector2Points(Point3d ptoA, Point3d ptoB) { Vector3d vec = new Vector3d(ptoB.X - ptoA.X, ptoB.Y - ptoA.Y, ptoB.Z - ptoA.Z); return vec; }


Guillermo Ramírez

p0223

ANEXOS

Estructura de RhinocCommon

ANEXO 1

RHINOCOMMON

RHINO GRASHOPPER

GRASHOPPER_IO

GRASHOPPER

RHINO PYTHON RHINO FOR MAC

RhinoRhino.ApplicationSettingsRhino.Collections CurveListRhino.CommandsRhino. Display CustomDisplay Text3dRhino.DocObjects RhinoObjectRhino.DocObjects.CustomRhino.DocObjects.TablesRhino.FileIORhino. Geometry Point3d Vector3d Box Brep Curve Polyline Rectangle3d SurfaceRhino. Geometry.Collections BrepFace BrepEdgeRhino. Geometry.Intersect CurveIntersection Intersection IntersectionEventRhino.InputRhino.Input.CustomRhino.PluginsRhino.RenderRhino.Render.CustomRhino.RuntimeRhino.Runtime.InteropWrapperRhino.UI

GH_ISerializable InterfaceGH_IO.SerializationGH_IO.TypesGH_IO.UserInterface

GH_InstanceServerGrasshopper.GUIGrasshopper.Kernel GH_Path GH_Document

NOTA: Se resaltan en negrita los NameSpace que utilizamos en los ejercicios del manual. Se muestran sólo las clases con las que vamos a trabajar.

Processing

01. Estructura básica de un programa de Processing02. El lienzo y la consola03. Algunas funciones de dibujo básico04. Algunas funciones de interacción básicas05. Ejemplos de aplicación

ANEXO 2


Guillermo Ramírez

p0228

01. Estructura de la interfaz de Processing: el lienzo y la consola

size(ancho, alto); //tamaño del lienzo background(155);

El lienzo es el espacio de pantalla en el que vamos a hacer nuestro dibujo de Processing y consiste en una rejilla de píxeles de color.

El lienzo tiene dos propiedades.- tamaño o size - color de fondo o background

El ancho y alto del lienzo se pueden llamar en cualquier

Es la ventana en la que imprimimos textodesde el codigo de Processing. Utilizamos dos funciones:

- print: escribe cadenas de caracteres de un modo continuo- println: escribe cadenas de caracteres añadiendo un salto de carro

El lienzo (canvas)

La consola

xy


Guillermo Ramírez

p0229

02. Colores y formas

Es el espacio de pantalla en el que vamos a hacer nuestro dibujo de Processing. Tiene dos propiedades.

- tamaño o size - color de fondo o background

El lienzo (canvas)


Guillermo Ramírez

p0230

03. Declaración de variables


Guillermo Ramírez

p0231


Guillermo Ramírez

p0232

02. El lienzo y la consola

// Esta primera parte es la que se ejecuta primero cuando el programa corre.así que declararemos las variables globales al principio del código, que podrán ser llamadas en cualquier apartado del programaint y = 0;

// a continuación, vienen las funciones setup y draw. cada programa tiene una sola de cada una de estas funciones. Los corchetes de cada una de ellas definen un bloque independiente

// el bloque de la función setup se ejecuta una única vez por programa y en ella colocamos, fundamentalmente, las propiedades del dibujo de processing void setup() { size(300, 300); //tamaño del lienzo}

// el bloque de la función draw se ejecuta continuamente hasta que el programa paravoid draw() { line(0, y, 300, y); //dibujo de una línea y = y + 4;}


Guillermo Ramírez

p0233

02. Algunas funciones básicas de dibujo en Processing

Dibujar un punto

point (x, y);x entero o decimal: coordenada x del punto y entero o decimal: coordenada y del punto

Dibujar una línea

line (x1, y1, x1, y1);x1 entero o decimal: coordenada x del punto origeny1 entero o decimal: coordenada y del punto origenx2 entero o decimal: coordenada x del punto destino y2 entero o decimal: coordenada y del punto destino

Dibujar un rectángulo

rect(x, y, ancho, alto); x entero o decimal: coordenada X del vértice superior izquierdoy entero o decimal: coordenada Y del vértice superior izquierdoancho entero o decimal: anchura del rectánguloalto entero o decimal: altura del rectángulo

Dibujar una elipse

ellipse(x, y, ancho, alto);x entero o decimal: coordenada X de la elipsey entero o decimal: coordenada Y de la elipsewidth entero o decimal: anchura de la elipseheight entero o decimal: altura de la elipse

Dibujar una curva

beginShape();curveVertex(x, y);endShape();x entero o decimal: coordenada X del vértice de la curvay entero o decimal: coordenada Y del vértice de la curva

Dibujar texto

PFont miFuente;miFuente = createFont(“FFScala”, 32); // crea automáticamente una fuente y la guarda en la carpeta “data” de nuestro dibujo de ProcessingtextFont(miFuente);// esta función asigna el tipo de fuente con la que se va a dibujar a continuacióntext(“hola cocacola”, x, y); texto caracter o cadena de caracteresx entero o decimal: coordenada X del textoy entero o decimal: coordenada Y del texto

Colocar una imagen

PImage p;p = loadImage(nombre);image(p, x, y);

nombre cadena de caracteres: nombre de la imagen, si está en la carpeta “data”, si no, ruta de la mismax entero o decimal: coordenada X de la imageny entero o decimal: coordenada Y de la imagen


Guillermo Ramírez

p0234

03. Propiedades del dibujo de Processing

Las propiedades fundamentales de lo que dibujamos en processing son las siguientes:

Color

Color de trazo

stroke(gray);stroke(gray, alpha);stroke(value1, value2, value3);stroke(value1, value2, value3, alpha);stroke(color);stroke(color, alpha);

Grosor de trazo

strokeWeight ();

Color de relleno

fill();

No dibujar trazo

noStroke();

No dibujar relleno

noFill();

Suavizar bordes

smooth();

No suavizar bordes

noSmooth();


Guillermo Ramírez

p0235

04. Algunas funciones básicas de interacción en Processing

Posición del ratón

mouseXmouseYpmouseXpmouseY

Eventos de ratón

mousePressed()mouseReleased()mouseMoved()mouseDragged()


Guillermo Ramírez

p0236

05. Ejemplos de aplicación

Dibujar una curva a partir de las coordenadas del ratón

void setup() { size(640, 200); background(102);}

void draw() { stroke(255); if(mousePressed) { line(mouseX, mouseY, pmouseX, pmouseY); }}

Dibujar una interfaz de interacción con botones

// tamaño visorint ancho = 450;int alto = 200;//tamaño botonesint lado = 30;//posicion botonesint posX = 50;int posY = 50;// colorescolor cBotInicial = color(80);color cBotEncima = color(20, 20, 180);color cBotPulsado = color(255);color colorRect;

void setup(){ size(ancho, alto); background(0); noStroke(); rectMode(CORNER);}

void draw(){ colorRect = cBotInicial; if ((mouseX >= posX && mouseX <= posX+lado) && (mouseY >= posY && mouseY <= posY+lado)) { colorRect = cBotEncima; } if(((mouseX >= posX && mouseX <= posX+lado) && (mouseY >= posY && mouseY <= posY+lado)) && mousePressed)


Guillermo Ramírez

p0237

{ colorRect = cBotPulsado; } fill(colorRect); rect(posX, posY, lado, lado); }

Glosario de términos

ANEXO 3

programación script RhinoCommon

SDK (Software Developement Kit)

Plug-in

lenguaje de programación

intérprete

máquina virtual

Common Language Runtime

C#

programación orientada a objetos

plataforma .NET

Proceso por el cual se escribe, se prueba, se depura, se compila y se mantiene el código fuente de un programa informático.

(Se traduce literalmente del inglés como “guión”, “archivo de órdenes”, sería la traducción adecuada).Se trata de un programa simple. Los scripts son casi siempre interpretados, es decir, que son ejecutados por un intérprete.

Es una SDK (Software Developement Kit) construída bajo la plataforma .NET para el desarrollo de plug-ins para todas las plataformas de Rhinoceros, esto es, Rhino 5 (32 y 64 bits), Rhino para Macintosh, Grasshopper y Phyton scripting para Rhino.

Conjunto de Herramientas de desarrollo que permiten la creación de aplicaciones para un determinado paquete o plataforma de software, hardware o plataformas similares.

En computación, se trata de un conjunto de componentes de software que añaden capacidades especificas a una aplicación mñas grande.

Fuente: wikipedia.org

Idioma artificial diseñado para expresar instrucciones que pueden ser llevadas a cabo por máquinas, como una computadora. Como tal idioma está formado por un conjunto de símbolos y reglas sintácticas que definen su estructura y el significado de sus expresiones.

Programa infrormático capaz de analizar y ejecutar otros programas.Los intérpretes realizan la traducción a código máquina (unos y ceros) a medida que ésta es necesaria, típicamente instrucción por instrucción y sin guardar el resultado de dicha traducción. Esto hace que los programas interpretados sean más lentos, pero a cambio más flexibles para reemplazar o añadir partes del programa y, además, ofrecen al programa un entorno no dependiente de la máquina donde se ejecuta el intérprete (lo que se conoce comúnmente como máquina virtual).

Software que emula a una computadora y puede ejecutar programas como si fuese una computadora real.

(”entorno en tiempo de ejecución de lenguje común”)Es el entorno de ejecución para los códigos de los programas de la plataforma .NET, como C# o Visual Basic.NET. Se encarga de compilar un código intermedio al código máquina nativo. Se ejecuta sólo en Microsoft Windows. No es exactamente una máquina virtual, pero su objetivo es el mismo.

Lenguaje de programación orientado a objetos desarrollado y estandarizado por Microsoft como parte de su plataforma .NET. Su sintaxis básica deriva de C y C++ y utiliza el modelo de objetos similar al de Java.

Paradigma de programación que usa objetos y sus interacciones para diseñar aplicaciones y programas informáticos. Está basado en varias técnicas, entre las que se incluyen la herencia, la abstracción, el polimorfismo y el encapsulamiento.

Plataforma de software, que corre principalmente en Microsoft Windows, que incluye una extensa biblioteca de clases soportada por diversos lenguajes de programación, como C# o Visual Basic.NET, y un entorno de software en el cual se ejecutan las aplicaciones (Common Language Runtime), similar a una máquina virtual de aplicaciones

www.frikearq.com

introducción al diseño generativo

con processingmiguel vidal calvet

guillermo ramírez camarerowww.frikearq.com

diseño generativo

Christopher Wren, plan de reconstrucción de Londres tras el incendio de 1666.

Christopher Wren, tipos normalizado de edificación del plan.

Christopher Wren, 51 iglesias del plan de reconstrucción de Londres.

Broadway boogie woogie, 1942-44, Piet Mondrian.

Two vehicle events, 1961, George Brecht.

Generator project, 1976-79, Cedric Price.

CASEY REAS, 2001, “Tissue: path 06”.

procesos


www.frikearq.com


idea


www.frikearq.com





www.frikearq.com



implementación(código fuente)



www.frikearq.com



implementación

información


entre objetos)


www.frikearq.com



implementación

resultados

información


entre objetos)


www.frikearq.com


2 paradigmas

- diseño paramétrico

- diseño discriminativo


www.frikearq.com




www.frikearq.com


datos



www.frikearq.com


algoritmo

datos datos



www.frikearq.com


algoritmo

resultados

datos datos



www.frikearq.com




www.frikearq.com


algoritmo

resultados

datos datos



www.frikearq.com


algoritmo

resultados

datos datos

evaluación



www.frikearq.com


algoritmo


resultados

datos datos

evaluación



www.frikearq.com


algoritmo


resultados

resultados

datos datos

evaluaciónsí



www.frikearq.com


algoritmo


resultados

resultados

datos datos

evaluaciónsí

noproceso de diseño discriminativo

aplicaciones prácticas


www.frikearq.com


diseño del proceso y no de un resultado concreto.01


www.frikearq.com




01

02


www.frikearq.com




automatizar la generación de múltiples soluciones adaptadas a un entorno.

01

02

03

dummy sustantivo

(in window display, for dressmaker) maniquí m (in tests, stunts) muñeco m; ventriloquist’s ~ muñeco de ventrílocuo (in US football) domi m

(for baby) (BrE) See Also→ pacifier

(fool) (colloq) bobo, -ba m,f (fam) (in bridge, whist) mano f del muerto; (player) muerto m

Fuente: Concise Oxford Spanish Dictionary © 2009 Oxford University Press

Esto NO es un “curso de programación”

Esto SÍ es un taller de scripting elaborado por DISEÑADORES para DISEÑADORES

programación


Fuente: Diccionario RAE.

script

(Se traduce literalmente del inglés como “guión”, “archivo de órdenes”, sería la traducción adecuada).

Se trata de un programa simple, generalmente, ejecutados por un intérprete.

processing


www.frikearq.com


se comunica con la consola virtual de java.

intérprete.

lenguaje y un entorno de programación de código abierto.010203

¿qué es processing?


www.frikearq.com


01. Estructura de la interfaz de Processing: el lienzo y la consola







El lienzo (canvas)

La consola

xy


www.frikearq.com


Comentarios en el código

Otro asunto que también va a sernos muy útil para hacer nuestros scripts es hacer comentarios dentro del código. Los comentarios son texto que forma parte del código, pero que la máquina va a obviar cuando lo está leyendo.

Esto nos puede servir para anotar aspectos relevantes del código o asuntos que son importantes recordar y también para ordenarlo. Esto nos servirá no sólo para no perdernos nosotros mismos sino para posibles futuras segundas o terceras personas que puedan acceder a él.

Existen dos maneras de comentar el código

- comentario de una sola línea: cualquier texto que escribamos en una línea a partir de los caracteres de barra “//” quedará comentado.

- comentario multilínea: cualesquiera línea o líneas de texto entre los caracteres de apertura “/*” y de cierrre “*/” quedarán comentadas.

//la función print sirve para imprimir textoprint(“hola, cocacola);

/*código de prueba escrito como primer ejercicio del manual de scripting de Frikearq :)*/

//la función print sirve para imprimir textoprint(“hola, cocacola);

El intérprete lee el código línea a línea de arriba a abajo y de izquierda a derecha. Para que el intérprete cambie de línea, es necesario añadir “;” al final de cada una de ellas, para que entienda que el código continúa en la siguiente línea.


www.frikearq.com


02. Algunas funciones básicas de dibujo en Processing

Dibujar un punto

point (x, y);x entero o decimal: coordenada x del punto y entero o decimal: coordenada y del punto

Dibujar una línea

line (x1, y1, x1, y1);x1 entero o decimal: coordenada x del punto origeny1 entero o decimal: coordenada y del punto origenx2 entero o decimal: coordenada x del punto destino y2 entero o decimal: coordenada y del punto destino

Dibujar un rectángulo

rect(x, y, ancho, alto); x entero o decimal: coordenada X del vértice superior izquierdoy entero o decimal: coordenada Y del vértice superior izquierdoancho entero o decimal: anchura del rectánguloalto entero o decimal: altura del rectángulo

Dibujar una elipse

ellipse(x, y, ancho, alto);x entero o decimal: coordenada X de la elipsey entero o decimal: coordenada Y de la elipsewidth entero o decimal: anchura de la elipseheight entero o decimal: altura de la elipse

Dibujar una curva

beginShape();curveVertex(x, y);endShape();x entero o decimal: coordenada X del vértice de la curvay entero o decimal: coordenada Y del vértice de la curva


www.frikearq.com


03. Propiedades del dibujo de Processing

Las propiedades fundamentales de lo que dibujamos en processing son las siguientes:

Color

Color de trazo


Grosor de trazo

strokeWeight ();

Color de relleno

fill();

No dibujar trazo

noStroke();

No dibujar relleno

noFill();

Suavizar bordes

smooth();

No suavizar bordes

noSmooth();


www.frikearq.com


04. Variables

Una variable es un nombre que se asigna a una cantidad conocida o desconocida de información para poder trabajar con este nombre, independientemente de la información que representa. La mayor parte del trabajo que vamos a realizar con nuestros scripts lo haremos a través de variables.

Para trabajar con variables es necesario inicializarlas según el tipo de dato que representa. El esquema básico que sigue el lenguaje de programación C# es el siguiente:



nombre de variable

(cualquier nombre excepto los reservados)

asignación valor

int a = 12 ;



nombre de variable

asignación valor

int a = 12 ;

Inicialización de variables

Asignación de valor a variables

Inicialización y asignación en la misma línea

int a = 12 ;

Tipos de datos primitivos que más vamos a utilizar y sus identificadores

tipo de dato nombre (en inglés) identificadornúmero entero integer int

número decimal double precision floating-point number

double

valor booleano (verdadero o falso)

boolean value (true o false) bool


Y un dato compuesto para empezar ...

tipo de dato nombre (en inglés) identificadorcadena de caracteres string string

NOTA: Una cadena de caracteres, o sea, texto, es un tipo de dato, como el nombre indica, compuesto de una sucesión de caracteres. El motivo por el cual lo mostramos en este punto, es que la salida out imprime cadena de caracteres, esto quiere decir, que para que devuelva cualquier dato hay que convertirlo previamente a string. Esto nos será útil para ir mostrando en pantalla lo que vayamos haciendo.


www.frikearq.com


// Esta primera parte es la que se ejecuta primero cuando el programa corre.así que declararemos las variables globales al principio del código, que podrán ser llamadas en cualquier apartado del programaint y = 0;




05 Estructura básica de un programa de Processing


www.frikearq.com


inicialización

comprobación

declaración


que establezcamos)

07. Estructuras iterativas

si es verdadero

si es falso



www.frikearq.com


08. Funciones: abstracción

Las funciones son subrutinas incluidas dentro de un programa más grande y que nos permite resolver una tarea específica. Las funciones son útiles para desarrollar tareas que se van a repetir dentro del programa principal y para, de esta manera, modular el código en apartados pequeños. Las funciones que devuelven un valor, se asigna con return.

Dicha subrutina, cuando es llamada dentro del código principal, hace que la lectura de ese código se detenga y se dirija a ejecutar el código de la subrutina. En ciertos lenguajes de programación, las funciones son subrutinas que devuelven un valor.

TIPO QUE DEVUELVE(en caso de que devuelvaalgún valor)

void

OPERACIONES DE LA FUNCIÓNOPERACIONES DE LA FUNCIÓN

VALOR QUE QUEREMOS QUE DEVUELVAreturn

NOMBRENOMBRE

{{

}}

Estructura de una función que devuelve un valorEstructura de una función que no devuelve ningún valor

;

(( )) PARÁMETROS DE LA FUNCIÓN(que hay que declarar en este punto)

PARÁMETROS DE LA FUNCIÓN(que hay que declarar en este punto)


www.frikearq.com


09. Estructura de una clase

class

CONSTRUCTOR (SOBRECARGAS)

METODOS

DECLARACIÓN DE PROPIEDADES

PROPIEDADES

NOMBRE

CONSTRUCTOR

MÉTODOS

{

{

{

}

}

}

NOMBRE DE LA CLASE


www.frikearq.com




Plug-in


intérprete

máquina virtual


C#

programación orientada a objetosplataforma .NET













con fines creativos en diseño

Introducción a la

Visualización de informaciónMiguel Vidalwww.frikearq.com

Réplica de un microscopio de van Leeuwenhoek, de finales del s. XVIIFuente: wikimedia.org

EJERCICIO PRÁCTICOVisualización de datos climáticos de la comunidad de Madrid

Sistema energético híbrido eólico solar

012

Nociones iniciales de computación

Lectura y filtrado de datos

Representación de datos

Nociones iniciales de computación

Comentarios e impresión por consola

Tipos de datos

Trabajo con variables

Estructuras condicionales

Estructuras de repetición

Gestión de cadena de caracteres

Trabajo con arrays

1

2

3

4

5

6

7

Imprimir por consola

Comentarios

de una línea

imprimir

// este texto no computa

// este texto tampoco

/* este texto no computani este tampoco*/

multilínea

imprimir con salto de carro

print ( texto ); println ( texto );

Colecciones de datos

vector o matriz array []

Datos compuestos

cadena de caracteres string String

Datos simples

tipo de dato nombre (en inglés) identificador

valor booleano boolean value bool

número entero integer int

número decimal floating-point number float


Datos

Variables

Colecciones de datos

Datos compuestos

Datos simples

declaración construcción asignación

identificador + nombre;

int miNum ;-

nombre+=+valor;

miNum = 10 ;

identificador + nombre;

String miTexto;

nombre+=+new+identificador();

miTexto = new String();

nombre+=+valor;

miTexto = “abc”;

String[] misDatos;

nombre+=+new+identificador[];

misDatos = new String[longitud];

nombre+=+{ , , };

misDatos= {“abc”, “def”};

Estructuras condicionales

comprobación

comprobación

declaración

si es verdadero

si es falso

if(comprobación){ declaración;}

else{ declaración;}

if(i > 0){ println(“hola”);}

else{ println(“cocacola”);}

inicialización

comprobación

declaración


que establezcamos)

si es verdadero

Estructuras de repetición

si es falso


for(int i = 0; i < 10; i++){ println(i);}

Formatear datos numéricos a texto

Concatenar texto

Longitud

Caracter

+

string.length();

string.charAt();

String.format( “tipo de formato”, variable numérica );

tipo de formato para enteros → %dtipo de formato para decimales → %f

Gestión de cadenas de caracteres

Arrays

Declaración

Construcción

Item

Longitud

Propiedades - sucesión de elementos (item)- ordenada- asignación de un índice (index) a cada elemento- tamaño definido, que se denomina “longitud” (length)

String[] datos;

datos = new String[ longitud ];

datos[ index ];

datos.length;

Filtrado (parsing) de datos

CÓDIGOS DE ANÁLISIS (14 dígitos)8 primeros dígitos: código de estación8-10 dígitos: código de parámetros10-12: código de técnica analítica12-14: código de período de análisis FECHA (6 dígitos)13-16: año16-18: mes18-20: díaDATOS (144 dígitos a partir de la posición 19)14-19: 1ª hora19-24: 2ª hora25-31: 3ª hora32-37: 4ª hora37-42: 5ª hora42-47: 6ª hora48-53: 7ª hora54-59: 8ª hora60-65: 9ª hora…

Ayuntamiento de Madridhttp://www.mambiente.munimadrid.es/opencms/opencms/calaire/consulta/descarga.html?__locale=esComunidad de Madridhttp://gestiona.madrid.org/azul_internet/html/web/InformExportacionAccion.icm?ESTADO_MENU=7_4

Procedencia de la información

Filtrado de la información

28065013070802110101080.0V095.0V041.0V08.00V01.00V02.00V03.00V05.00V013.0V014.0V09.00V09.00V04.00V06.00V05.00V05.00V05.00V05.00V07.00V06.00V07.00V09.00V021.0V032.0V

28065013070802110101

toda la líneadatos

datos

índices

índices

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81

0 1 2 3 4 5 6 7 8 9 10 11 12 13 1415 16 17 18 19

Dibujo con Processing







El lienzo (canvas) La consola

xy

Interfaz de Processing: editor, consola y lienzo

Color

Color de trazo


Grosor de trazo

strokeWeight ();

Color de relleno

fill();

No dibujar trazo

noStroke();

No dibujar relleno

noFill();

Suavizar bordes

smooth();

No suavizar bordes

noSmooth();

Propiedades de dibujo

Dibujar un puntopoint (x, y);x entero o decimal: coordenada x del punto y entero o decimal: coordenada y del punto

Dibujar una línealine (x1, y1, x1, y1);x1 entero o decimal: coordenada x del punto origeny1 entero o decimal: coordenada y del punto origenx2 entero o decimal: coordenada x del punto destino y2 entero o decimal: coordenada y del punto destino

Dibujar un rectángulorect(x, y, ancho, alto); x entero o decimal: coordenada X del vértice superior izquierdoy entero o decimal: coordenada Y del vértice superior izquierdoancho entero o decimal: anchura del rectánguloalto entero o decimal: altura del rectángulo

Dibujar una elipse ellipse(x, y, ancho, alto);x entero o decimal: coordenada X de la elipsey entero o decimal: coordenada Y de la elipsewidth entero o decimal: anchura de la elipseheight entero o decimal: altura de la elipse

Funciones de dibujo básicas

Dibujar texto

PFont miFuente;miFuente = createFont(“FFScala”, 32); // crea automáticamente una fuente y la guarda en la carpeta “data” de nuestro dibujo de ProcessingtextFont(miFuente);// esta función asigna el tipo de fuente con la que se va a dibujar a continuacióntext(“hola cocacola”, x, y); texto caracter o cadena de caracteresx entero o decimal: coordenada X del textoy entero o decimal: coordenada Y del texto

Colocar una imagen

PImage p;p = loadImage(nombre);image(p, x, y);

nombre cadena de caracteres: nombre de la imagen, si está en la carpeta “data”, si no, ruta de la mismax entero o decimal: coordenada X de la imageny entero o decimal: coordenada Y de la imagen

// Esta primera parte es la que se ejecuta primero cuando el programa corre.// Aquí declararemos las variables globales, que podrán ser llamadas más adelanteint y = 0;




Estructura de un programa con refresco de lienzo

Anexo I:Referencias y bibliografía

Edward Tufte“Envisioning information”; Graphics Pr (May 1990), ISBN-10: 0961392118.“The visual display of quantitative information”; Graphics Pr, 2nd edition (May 2001; ISBN-10: 0961392142.

Rudolf ArnheimArte y percepción visual; Alianza Editorial (2 de noviembre de 1999), ISBN-10: 8420686913.

Portales webVisualizar – Medialab Prado, http://medialab-prado.es/visualizarhttp://visualcomplexity.comhttp://cs171.org/ (Harvard School of Engineering and Applied Sciences)http://processing.comhttp://wolframalpha.comhttp://bestiario.org

Ejemplos de otras disciplinasInformación científica: NASA, http://www.nasa.gov/; EADS, http://www.eads.com/eads/int/en.html.

Anexo II:Glosario de términos



Plug-in


intérprete

máquina virtual


C#

programación orientada a objetosplataforma .NET














www.frikearq.com


February 2013frikearq.com

Date post:	11-Aug-2015
Category:	Documents
Upload:	michividal
View:	138 times
Download:	11 times

MIGUEL VIDAL Teaching Curriculum en Print

Documents