of area...that is quite a lot depending on the application.
I was able to do a little parser to format the data correctly for Elk. It is not so elegant, but I include it as an example. I was able to retrieve more that 50,000 nodes. Of course, it takes time to download, so this blocks GH for a few seconds depending on how much you are retrieving.
One thing to note, the method I am using (XDocument.Load(url)) does not seem to include a 'timeout' property. Meaning that large queries might timeout...this happened to me. An alternative would be to just do a WebRequest which does have a timeout property or use an XMLResolver which I suppose could also have this property.
Here is the script. It has the following inputs:
urlPre (string):the url prefix for the mapquest xapi api. Should be:
"http://open.mapquestapi.com/xapi/api/0.6/*[bbox="
path (string):this is where you want to save the incoming data. I suppose this could be done without a local file, all in memory, but since elk wants a file name, it is here. I save data to a folder in my c drive, so a possible value could be:
"C:\Data\map.osm"
left (string):min longitude in decimal degrees
bottom (string):min latitude in decimal degrees
right (string):max longitude in decimal degrees
top (string):max latitude in decimal degrees
The output is just the filename you put into the Path input. You can then feed this to Elk.
Here is the script:
private void RunScript(string urlPre, string path, string left, string bottom, string right, string top, ref object A){string url = urlPre + left + "," + bottom + "," + right + "," + top + "]"; System.Xml.Linq.XDocument xDoc = System.Xml.Linq.XDocument.Load(url.ToString()); //Mapquest does not seem to return a proper bounds line, and it seems this throws something off, this next line adds the appropriate line System.Xml.Linq.XElement xElem = System.Xml.Linq.XElement.Parse(""<bounds minlat=\"" + bottom + "\" minlon=\"" + left + "\" maxlat=\"" + top + "\" maxlon=\"" + right + "\" />""); xDoc.Root.Add(xElem); xDoc.Save(path);A = path;}
This is 76995 nodes from what I can tell. Took about 129 seconds to compute everything according to GH.
…
troducción a su plugin de modelado paramétrico, Grasshopper.
Con este tipo de herramientas podemos pensar formas más allá de las cajas para diseñar, porque seremos capaces controlar con total rigor geometrías muy complejas.
En el siguiente video, podemos ver un ejemplo realizado durante un curso impartido anteriormente en Madrid por el profesor, Francisco Tabanera, en el que se realiza una interpretación del proyecto de BIG para la Biblioteca Nacional de Kazajstán.
<a title="Interpretación de la Biblioteca Naiconal de Kazakstan, de BIG" href="http://www.youtube.com/watch?v=YLldO-SxgPw" target="_blank"></a>
A lo largo del curso se realizarán diferentes ejemplos que podrán ser realizados por todos los asistentes, ya que no es necesario ningún conocimiento previo para su seguimiento.
El curso se desarrollará en las oficinas de Arquitecton en Barcelona con el siguiente horario:
HORARIO
Sábado 1 de Marzo
De 9.30 a 13.30h.
Sábado 1 de Marzo
De 15.30 a 19.30h.
El curso está planteado para un máximo de 9 alumnos, para conseguir el máximo aprovechamiento posible por parte de los mismos.
El curso tiene un precio de 90€. Estudiantes y desempleados tienen un descuento del 10%. Es posible asegurarte una plaza con un primer pago de 25€ a modo de reserva.
Apúntate aquí…
ng in Grasshopper?
As a general recommendation for developers in Grasshopper who are writing a part of their library which is performance-sensitive (please note: often the performance sensitive part is very limited) is to write it in C#, or maybe even C, or maybe even assembly :). Of course, the closer to the machine you will be, the easier it will be to harness all minimal optimizations. However, there is always a compromise between "getting things done" and "making them best" and this boundary is not very easy to catch, right?
If you want to have significant speed improvements for numerical calculations, I would at least recommend developing with C# in a compiled component using Visual Studio or SharpDevelop. The reason is: in order to provide the line number of possible errors, Grasshopper compiles C# scripts in debug mode! They will be much less optimized than what is possible even with today's technology. This does not preclude keeping the project open-source, if that is one of your goals.
Regarding the actual list:
1) Yes, the implied loop will probably be slower than just a simple for loop. This is because Grasshopper code has to keep track of more things than the ones you could be considering with your knowledge of of your very-special case. However, a factor of 10 is simply not acceptable and is likely a symptom of something else. In fact, I think I remember fixing a bug around that in Rhino WIP. However, it appears to be still slower also there. I've added a bugtracking item here.
2) If you are able to do all casts that are involved, and do them as Grasshopper does, please write that code that way. For example, if you supply a curve to an input with number hint, Grasshopper computes the length of the curve. There will have to be an "if" that checks if the input is a curve somewhere (or some similar construct). This aid for designers is what slows down the hint input.
3) Grasshopper has to keep side effects at bay. For example, components B and C are both connected to outputs of A. If you edit data in component B, and that data came from A you of course expect that data to be unchanged in C. This means that, for even lists of numbers, Grasshopper has to perform a deep copy of the output for each input. Otherwise, what happens if B sorts the list and C finds the index of the smallest number? This could be improved if GH components had some way of flagging themselves as non-data-mutating (constant). The fact that, by supplying special types, Grasshopper has no way of performing copies will likely speed things up. But be aware of possibly very annoying side effects creeping in if data is not immutable. Another option is performing the copy "optimally", just where you need it, because you know where your data is used. This is not information that is available to GH at present.
Does this help?
Thanks again for your input,
Giulio--Giulio Piacentinofor Robert McNeel & Associatesgiulio@mcneel.com…
ints. Anyway this is made for AEC purposes (wavy roofs/envelopes and the likes) and is classified as internal (but I could provide a "light" version).
To give you a very rough idea: C# rebuilds first any input list of nurbs > then samples the control points in a tree > then excludes (or not) the "peripheral" points (case: closed in U/V surfaces) > then "picks" some of them according a rather vast variety of options (~30) > then modifies these either individually (that's only possible with code and it's a bit tricky) or via any collection of push/pull attractors or randomly or ... > then "joins" the 2 sets together (modified + unmodified) > and finally does the new nurbs. Only 456 lines of code that one.
With regard the Dark Side: C# would be my recommendation (P is ala mode, mind) for a vast variety of reasons (less than 10% of them are GH related).
If you decide to cross the Rubicon:
How to go to hell (and stay there) in just 123 easy steps:
Step 1: get the cookies
The bible PlanA: C# In depth (Jon Skeet).
The bible PlanB: C# Step by step (John Sharp).
The bible PlanC: C# 5.0 (J/B Albahari) > my favorite
The reference: C# Language specs ECMA-334
The candidates:
C# Fundamentals (Nakov/Kolev & Co)
C# Head First (Stellman/Greene)
C# Language (Jones)
Step 2: read the cookies (computer OFF)
Step 3: re-read the cookies (computer OFF)
...
Step 121: open computer
Step 122: get the 30 steps to heaven (i.e. hell)
Step 123: shut down computer > change occupation/planet
May The Force (the Dark Option) be with you.
…
serveral questions:the first thing is in c++ i have to implement more methods than in my c# test project.
they are:
int MyGhComponent::MasterParameterIndex::get(){ return 0;}void MyGhComponent::MasterParameterIndex::set(int index){ }bool MyGhComponent::IsValidMasterParameterIndex::get(){ return 1;}
i found no hint for the implementation of that interfaces. could someone tell me that is correct ?OK, it works, but is it well writen ? What is the MasterParameterIndex?
the second "bigger" problem is, i want to have an output of an pointlist.X y Z 1.2 1.3 1.12.1 5.2 9.2...
my first approch was to use a
void MyGhComponent::RegisterOutputParams(GH_Component::GH_OutputParamManager^ pManager){pManager->Register_PointParam("Coordinate", "XYZ", "Node-Coordinate");}
and
void MyGhComponent::SolveInstance(IGH_DataAccess^ DA){Collections::Generic::List<GH_IO::Types::GH_Point3D>^ pnt = gcnew Collections::Generic::List<GH_IO::Types::GH_Point3D>(); for (int i = 0; i < 10; i++) { GH_IO::Types::GH_Point3D^ point = gcnew GH_IO::Types::GH_Point3D(i, i, i); pnt->Add(i); } DA->SetDataList(3, pnt);}
but this exampel doesn't work...i wirte a small workaround and use the following
pManager->Register_DoubleParam("X-Koordinate", "X", "X"); pManager->Register_DoubleParam("Y-Koordinate", "Y", "Y"); pManager->Register_DoubleParam("Z-Koordinate", "Z", "Z"); Collections::Generic::List<double>^ pntx= gcnew Collections::Generic::List<double>(); Collections::Generic::List<double>^ pnty= gcnew Collections::Generic::List<double>(); Collections::Generic::List<double>^ pntz= gcnew Collections::Generic::List<double>(); ... add .. ect.
this workaround do the job, but i want a better soulution. and i know somewhere out there sould be a better solution. i want to use 3D Points directly in GH without list conversation.
so somebody a familiar with c++ / cli ? and could give me some tipps or a soulution ?
the first thing is: what is the right RegisterOutputParams ?
and witch data type is the right ? Point3d doesn't work. so i try GH_IO::Types::GH_Point3D and Rhino::Geometry::Point3d ...
br Friedrich…
.
Things have been working swimmingly in many areas of the plugin, but one particular problem has been tough to solve. I have two components that are trying to read/write to the same memory at the same time, causing Rhino exceptions and crashes.
The conflicts appear to be happening between two components -- one is a "Layer Events Listener" that reports essentially what type of layer event just happened. The other is a "Set Layer Visibility" component that toggles the visibility of a list of layers.
The code:
public class LayerTools_LayerEventsListener : GH_Component { /// <summary> /// Initializes a new instance of the LayerTools_LayerListener class. /// </summary> public LayerTools_LayerEventsListener() : base("Layer Events Listener", "Layer Listener", "Get granular information about the layer events happening in the Rhino document.", "Squirrel", "Layer Tools") { }
/// <summary> /// Registers all the input parameters for this component. /// </summary> protected override void RegisterInputParams(GH_Component.GH_InputParamManager pManager) { pManager.AddBooleanParameter("Active", "A", "Set to true to listen to layer events in the Rhino document.", GH_ParamAccess.item, false); pManager.AddTextParameter("Exclusions", "E", "Provide a list of exclusions to stop reading specific events (Added, Deleted, Moved, Renamed, Locked, Visibility, Color, Active).", GH_ParamAccess.list); pManager[1].Optional = true; }
/// <summary> /// Registers all the output parameters for this component. /// </summary> protected override void RegisterOutputParams(GH_Component.GH_OutputParamManager pManager) { pManager.AddBooleanParameter("Initialized", "I", "Whether the listener changed from passive to active.", GH_ParamAccess.item); pManager.AddTextParameter("Document Name", "doc", "Name of the Rhino document that is changing.", GH_ParamAccess.item); pManager.AddTextParameter("Layer Path", "path", "Path of the modifed layer.", GH_ParamAccess.item); pManager.AddIntegerParameter("Layer Index", "ID", "Index of the modified layer.", GH_ParamAccess.item); pManager.AddIntegerParameter("Sort Index", "SID", "Sort index of the modified layer.", GH_ParamAccess.item); pManager.AddTextParameter("Event Type", "T", "Type of the modification.", GH_ParamAccess.item); pManager.AddBooleanParameter("Added", "A", "If the layer has been added.", GH_ParamAccess.item); pManager.AddBooleanParameter("Deleted", "D", "If the layer has been deleted.", GH_ParamAccess.item); pManager.AddBooleanParameter("Moved", "M", "If the layer has been moved.", GH_ParamAccess.item); pManager.AddBooleanParameter("Renamed", "R", "If the layer has been renamed.", GH_ParamAccess.item); pManager.AddBooleanParameter("Locked", "L", "If the layer locked setting has changed.", GH_ParamAccess.item); pManager.AddBooleanParameter("Visibility", "V", "If the layer's visibility has changed.", GH_ParamAccess.item); pManager.AddBooleanParameter("Color", "C", "If the layer's color has changed.", GH_ParamAccess.item); pManager.AddBooleanParameter("Active", "Act", "If the active layer has changed.", GH_ParamAccess.item); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { bool active = false; List<string> exclusions = new List<string>();
DA.GetData(0, ref active); DA.GetDataList(1, exclusions);
RhinoDoc thisDoc = null;
bool initialize = false;
string dName = null; string activePath = null; int layerIndex = -1; int sortIndex = -1; string eventType = null; bool added = false; bool deleted = false; bool moved = false; bool renamed = false; bool locked = false; bool visibility = false; bool color = false; bool current = false;
if (active) { thisDoc = RhinoDoc.ActiveDoc;
initialize = (!previouslyActive) ? true : false;
RhinoDoc.LayerTableEvent -= RhinoDoc_LayerTableEvent; RhinoDoc.LayerTableEvent += RhinoDoc_LayerTableEvent; previouslyActive = true;
} else {
RhinoDoc.LayerTableEvent -= RhinoDoc_LayerTableEvent; previouslyActive = false; }
if (ev != null) { dName = ev.Document.Name; layerIndex = ev.LayerIndex; eventType = ev.EventType.ToString();
if (!exclusions.Contains("Active")) { if (ev.EventType.ToString() == "Current") { // active layer has just been changed current = true; }
}
if (!exclusions.Contains("Moved")) { if (ev.EventType.ToString() == "Sorted") { // active layer has just been changed moved = true; }
}
if (!exclusions.Contains("Added")) { if (ev.EventType.ToString() == "Added") { // layer has just been added activePath = ev.NewState.FullPath; added = true; }
}
if (!exclusions.Contains("Active")) { if (ev.EventType.ToString() == "Deleted") { // layer has just been added
deleted = true; } }
if (ev.EventType.ToString() == "Modified") { // layer has been modified activePath = ev.NewState.FullPath;
//skip sortindex eventType = ev.EventType.ToString();
if (ev.OldState != null && ev.NewState != null) { if (!exclusions.Contains("Locked")) { if (ev.OldState.IsLocked != ev.NewState.IsLocked) locked = true;
} if (!exclusions.Contains("Visibility")) { if (ev.OldState.IsVisible != ev.NewState.IsVisible) visibility = true; }
if (!exclusions.Contains("Moved")) { if (ev.OldState.ParentLayerId != ev.NewState.ParentLayerId) moved = true; }
//if (ev.OldState.SortIndex != ev.NewState.SortIndex) moved = true; if (!exclusions.Contains("Renamed")) { if (ev.OldState.Name != ev.NewState.Name) renamed = true; }
if (!exclusions.Contains("Color")) { if (ev.OldState.Color != ev.NewState.Color) color = true; } }
} }
DA.SetData(0, initialize); DA.SetData(1, dName); DA.SetData(2, activePath); DA.SetData(3, layerIndex); DA.SetData(4, sortIndex); DA.SetData(5, eventType); DA.SetData(6, added); DA.SetData(7, deleted); DA.SetData(8, moved); DA.SetData(9, renamed); DA.SetData(10, locked); DA.SetData(11, visibility); DA.SetData(12, color); DA.SetData(13, current);
}
static bool previouslyActive = false; Rhino.DocObjects.Tables.LayerTableEventArgs ev = null;
void RhinoDoc_LayerTableEvent(object sender, Rhino.DocObjects.Tables.LayerTableEventArgs e) { ev = e;this.ExpireSolution(true); }
And for the layer visibility component:
public LayerTools_SetActiveLayer() : base("Set Active Layer", "SetActiveLayer", "Set the active layer in the Rhino document.", "Squirrel", "Layer Tools") { }
/// <summary> /// Registers all the input parameters for this component. /// </summary> protected override void RegisterInputParams(GH_Component.GH_InputParamManager pManager) { pManager.AddBooleanParameter("Active", "A", "Set to true to change the active layer in Rhino.", GH_ParamAccess.item, false); pManager.AddTextParameter("Path", "P", "Full path of the layer to be activated.", GH_ParamAccess.item); }
/// <summary> /// Registers all the output parameters for this component. /// </summary> protected override void RegisterOutputParams(GH_Component.GH_OutputParamManager pManager) { pManager.AddIntegerParameter("Layer ID", "ID", "Index of layer that has been activated.", GH_ParamAccess.item); pManager.AddBooleanParameter("Status", "St", "True when the layer has been activated.", GH_ParamAccess.item); }
/// <summary> /// This is the method that actually does the work. /// </summary> /// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param> protected override void SolveInstance(IGH_DataAccess DA) { bool active = false; string path = "";
if (!DA.GetData(0, ref active)) return; if (!DA.GetData(1, ref path)) return;
int layer_index = -1; bool status = false;
if (path != null) {
Rhino.RhinoDoc doc = Rhino.RhinoDoc.ActiveDoc; Rhino.DocObjects.Tables.LayerTable layertable = doc.Layers;
layer_index = layertable.FindByFullPath(path, true);
if (layer_index > 0) { // if exists RhinoDoc.ActiveDoc.Layers.SetCurrentLayerIndex(layer_index, true); status = true; } }
DA.SetData(0, layer_index); DA.SetData(1, status); }
Now originally I was getting exceptions when changing multiple layers' visibility properties, which would cause the Event Listener to fire and try to read the Visibility property before the memory has been released by the Set Layer Visibility component. That led me to add an "Exceptions" input, that would allow me to disable the reading of Visibility events at the source in the Layer Events listener. That helped me manage about 95% of the crashes I was getting, but I still get strange crashes in other event properties, even when that property shouldn't be affected. For instance, I am getting a crash here on the Name property in the event from the delegate function, even though I am only changing Visibility at any one time:
I have a few ideas but they all seem pretty hacky. One is to try to set a flag that is readable by any component in the plugin -- so that the event listener can see if a "set" component is currently running and abort before causing an exception. The other is creating a delay in the event listener, somthing like 200ms, to allow any set components to finish what they are doing before reading the event. Neither seems super ideal.
Any ideas?
Thanks,
Marc
…
ices to regulate light and view while simultaneously producing both ornamental as well as material effects. The workshop will make extensive use of our Digital Fabrication equipment, coupled with Parametric Patterning techniques in Grasshopper for Rhinoceros. In a fast-paced and hands-on learning environment, participants will explore issues pertaining to the Coordination of Fabricated Parts through Unique Object Attributes, Baking Objects with User-Defined Attributes, Nesting Optimization with Rhinonest for Grasshopper, as well as the precise creation and manipulation of Computational Geometry through parametric modeling interfaces.
The workshop will begin with an examination of a set of Parametric Schemas as a means of identifying a suite of conceptual approaches to the regulation of light and view. Site-Specific Influencers such as Solar, Shading, Air Flow, and Viewing requirements will serve as Catalysts for the Parametric Articulation of a series of screening devices through shifting, perforating, and graduating Patterns. Emphasis will be placed on consistent organization of data through Lists and Data Trees and best practices for Professional Workflow Integration, File Modularity, and Data Visualization in Grasshopper.
SCREENING will focus on the Grasshopper, supplemented by the add-on Rhinonest as a means of fully integrating fabrication logics into Parametric workflows. The workshop is structured to allow each participant time to iteratively develop design prototypes, moving quickly from digital design environments to material artifacts and back again. As the next installment in the modeFab series, participants in this workshop will be introduced to and work directly with a large-format CNC Laser Cutter to develop scaled and 1:1 Component Assemblies. This workshop, particularly well suited for intermediate users, offers an in-depth and rigorous expansion on the topics of Algorithmic Design, Computational Geometry, and Parametric Modeling through the lens of Digital Fabrication and Prototyping with Grasshopper. As part of a larger online infrastructure, modeLab, this workshop provides participants with continued support and knowledge to draw upon for future learning.
Attendance will be limited to provide each participant maximum dedicated time with instructors.
Participants should be comfortable with the fundamental concepts of parametric design and general usage of Grasshopper.
Topics:- Parametric Design :: Fundamental Concepts and Essential Skills- Data Structures :: Working with Lists and Data Trees- Patterning Logics :: Shifting, Perforating, and Gradients- Pressures + Influencers :: Working with Attractors, Image Mapping, and Data Sampling Strategies- Material Strategies :: Folding, Lamming, and Lapping- Detailing :: Connection Logics and Tolerance- Coordination :: Logical Naming, Cut Order, and Sheet/Part Management- Fabrication Workflows :: Layouts and Nesting with Rhinonest…
year, international teams located in key cities around the globe explore a common agenda with projects that are deeply embedded in diverse local conditions. Because of this, participants have an international laboratory to test their design hypothesis, understanding how design conclusions derived locally can be tested and evolved globally in different cities where other teams reside. This intensive two week course connects each participant to ongoing research agendas in robotics, simulation, physical computing, parametric design, digital fabrication, and other relevant emerging design methodologies. Specific emphasis is placed on understanding the multiscalar implications of design conclusions, thus creating critical research advanced on the application of new technologies in design.
HYPER CITIES
The way we describe and understand cities today is radically changing, and alongside this change there is also a radical transformation in the tools we use to design them. Cities call for a different approach towards the development of new multi-scalar strategies in urban design and planning solutions. Cities can be described as systems of networked ecologies: a series of co-dependent aggregations revolving around environmental mitigation, land-use organization, communication and service delivery. These generate a complexity that can be organized through technology, laws, political pressures, disciplinary desires, environmental constraints and social interaction. In fact networked ecologies embody the dominant form of organization today: the network, be it telematic, physical or even social.
GSS16 will focus on the potentials of this network to work not only at an urban scale, but also across diverse cities, interconnecting and expanding them. These will ultimately create a dynamic and interactive system of “HYPER- CITIES”: A variety of city-sensors (digital or analogue) processing and transferring information in explicit manifestations, interrelating with the collective environment.
The GSS16 will be directed by IaaC in collaboration with multiple Nodes participating in the course from and in different parts of the globe. All the Nodes engaged in the GSS16 will be challenged to define a 1:1 urban machining intervention transferring and digitally interrelating multiple sets of data collected from hyper-connected cities. The goal is to work as a globally distributed campus to generate a hyper-network of interventions that communicate to each other both locally and globally.
…
Added by Aldo Sollazzo at 3:17am on February 23, 2016
ion, extract structural data, produce 2d drawings, and exchange data with other external software. Nemo also includes free tools to create parametric shapes, such as Naca profiles, hydrofoils, keels, rudders, blade propellers, and sail plans.
Born in 2018 as an academic research project at ENSTA Bretagne, Nemo grew up since, immersed in professional naval architecture practice with L2Onaval.
From 2021, Nemo is now available for purchase with commercial or educational licenses. Following license levels are provided to fit every needs depending of user activity :
Free (Designer)
Level 1 (Section + Hydrostatics + Visualization)
Level 1 + 2 (Section + Hydrostatics + Visualization + Resistance + Structure)
We can also help you make best use of our software, provide project guidance, establish specific workflow and create custom tools.
Requirements
Microsoft Windows 10 or Apple Mac OS 12 Monterey :
McNeel Rhinoceros 7 SR26
(Other Rhinoceros, Windows and Mac OS versions have not been tested but may work)
Additional info
Food4Rhino Download
Discourse Forum
Facebook Page
Linkedin Page
Nemo Website
Credits
Authors : Mathieu VENOT
Contributors : Paul POINET, Laurent DELRIEU
…