uld help me to optimize the script, so it works reliable.
At the end the script should work only by the input of the following informations:
- Top-Curve
- Bottom-Curve
- accuracy ( like poly-count)
- is the bowl an open or closed structure?
This is an example of a good result:
From here its probably the best if you open both attached files, so you understand the problems.
1. Bug:
Offset direction of the bottomcurve needs to be set up by hand sometimes.
The script uses "loft" on a bunch of 3pt Arcs to create transitions. Arc 3pts" needs a "Point B" on the offset of the bottom line. Sometimes the offset is inverted, so i need to change it by hand.
The rule to make it work correct is: "The offset of the bottom line goes into the same direction as the top line, but on the same hight as the bottom line."
How can i implement this in GH?
2. Bug:
The floor generation needs a lot of guessing the right index numbers of lists.
The script uses 2x "Deconstruct Brep" to find the actual bottom curve of the created transition Brep. "Patch" is used to create a floor from this curve.
If the bowl is an open structure, the script creates a line between the endpoints of the bottom curve to close it, in order to create a trimmed "Patch". But again, you have to set up the right Index Numbers by hand...
3. Bug:
If the bowl is an open structure and the endpoints of the top-line and the bottom-line are the same the lofting is not working. At the moment I use a script that finds double points in the list and deletes it.
But the the result is, that the loft is not starting at the beginning or the end. Here is an Image.
I have only a little experience in gh, but i really want to learn more.
Thank you all for your help!…
g by a given diameter and some shapes.
What I've done: 1. diameter definition: to find the final object diameter
2. rails definitions: from a initial rails and diameter definition I've find a scaling factor in order to create the final rails with the same form of initial rails but with the wanted distance from the center.
I find the scaling factor using the ray and the distance of a projected point of initial rail to the plane XZ
3. shapes definitions: like the rails definition. I used more than one shape because sometimes I need particular forms along the path.
The sweep 2 rail component gives me a no good result
I tried the options inside the components in order to manipolate the data, but I don't found the solution.
If I bake the final rails and shapes, the sweep 2 rail in RH (selected object) works well, but in GH no (red object).
I attach the RH and GH files for all who can help me Thanks
Filippo…
rch, september, june.
I did two kind of simulation. The first one - just one hour 10h and then 15:30. The second, 10:00 to 15:30h. I think that's something wrong with the results kWh/m² because the biggest values for radiation, are for winter. And the results simulation 10:00 to 15:30h the result are different too, the biggest values for winter (june), then september, march, and them december (summer)
The results are (kWh/m²)
10:00h 15:30h 10 to15:30h
21/03 0,69 1,15 2,61
21/06 1,14 1,13 3,71
23/09 0,96 0,90 2,79
21/12 1,31 1,22 2,45
I will be very gratiful with your answer I'm using this software to a important academic work, and in my Country Its not commom use this software, I don't know anyone that could help me with this. I'd like to encourage university start to use this kind of software.
Thank you
Camila
…
rent actors to work together in real time on an architectural project.
DixieVR was born from the idea that virtual reality could become a fantastic tool for architecture and architects, not only for virtual tours but for the conception at its very core. Inspired by the efficiency of sandbox games, DixieVR will allow you to build a fully parametric 3D model from scratch in a very intuitive way and to simulate various factors like natural and artificial light, gravity, and more. DixieVR is also multi-user oriented : several people, architects or not, are able to work together in real time on the same 3D model and in the same shared immersive environment !
The project started in the Digital Knowledge department of Paris-Malaquais Architecture School.
The DixieVR Softwares can be found here : dixievr.github.io
// Interoperability
DixieVR deals with .dix files. For more information about this file format, please refer to the Interoperability documentation of DixieVR.
You can use this DixieIO plugin for Grasshopper/Rhinoceros for exchanging data between DixieVR (PC) & DixieViewer (Android).
You can import or export objects at any time inside a DixieVR scene. The Software also come with a library of premade objects that you might find useful. Adding your own premade objects to this library might be a good habit.
If you are hosting a scene, you also have the choice to open a .dix file directly from the main menu, this will load the last scene in which the geometry has been saved.
// Plugin
The DixieVR Plugin can be found in the Extra tab, come with 3 components and a example definition:
Dixie2Gh : Import DixieVR geometry to Grasshopper/Rhinoceros reading a .dix file (up to 1000 beams and/or 750 faces).
G2D_Polylines : Export Grasshopper/Rhinoceros Polylines to DixieVR writing a .dix file (up to 1000 line segments).
G2D_Mesh : Export Grasshopper/Rhinoceros Mesh to DixieVR writing a .dix file (up to 750 triangulated faces).
To install:
In Grasshopper, choose File > Special Folders > Components folder. Place the DixieIO_01.gha file there.
Right-click the file > Properties > make sure there is no "blocked" text.
Restart Rhinoceros or Unload Grasshopper.
// Contact - DixieVR
vr.dixie@gmail.com dixievr.github.io
- Oswald Pfeiffer oswaldpfeiffer.com
- Mathieu Venot mathieuvenot.com…
mesh by an infinite plane
Namespace: Rhino.GeometryAssembly: RhinoCommon (in RhinoCommon.dll) Version: 5.0.15006.0 (5.0.20693.0)
Syntax
C#
public Mesh[] Split( Plane plane )
Visual Basic
Public Function Split ( _ plane As Plane _ ) As Mesh()
Parameters
plane
Type: Rhino.Geometry..::..Plane[Missing <param name="plane"/> documentation for "M:Rhino.Geometry.Mesh.Split(Rhino.Geometry.Plane)"]
Return Value
[Missing <returns> documentation for "M:Rhino.Geometry.Mesh.Split(Rhino.Geometry.Plane)"]
See Also
Mesh Class
Rhino.Geometry Namespace
Last updated 3 June 2011 - Robert McNeel and Associates
Send comments on this topic to steve@mcneel.com
Report wishes and bugs: https://github.com/mcneel/rhinocommon/issues
Is this the function?
I have a VB component with this:
a = rhino.Geometry.Mesh.CreateBooleanSplit(x, y)
but this is a boolean split, so I have only one mesh, with the intersection. I would like to have several splitted meshes.
Thank you in advance again.
…
ndrea Graziano (Co-de-iT) Arch. Salvo Pappalardo (AION architecture) Arch. Giovanni Basile (Officina Ermocrate)
[.] Descrizione:
Modulo 1 Il workshop è finalizzato a fornire ai partecipanti i fondamenti della modellazione parametrica e generativa attraverso Grasshopper, plug-in di programmazione visuale per Rhinoceros 3D (uno dei più diffusi modellatori NURBS per l‘architettura e il design). Il workshop mira a gestire e sviluppare il rapporto tra informazione e geometria lavorando sui sistemi di involucro in condizioni specifiche. La discretizzazione di superfici (pannellizazione sia Nurbs che Mesh), la modellazione delle geometrie attraverso informazioni (siano esse provenienti da dati di analisi ambientali, da mappe di colore o da database), l’estrazione e la gestione di informazioni richiedono la comprensione delle strutture dei dati al fine di definire un processo che va dalla progettazione alla costruzione. I partecipanti impareranno come costruire e sviluppare strutture di dati parametrici per informare geometrie ‘data-driven’ e come estrarre le informazioni rilevanti da tali modelli per il processo di costruzione.
Modulo 2 Il workshop, volto a promuovere le nuove tecnologie digitali di supporto alla progettazione e alla fabbricazione, fornirà ai partecipanti, utilizzando Grasshopper, gli strumenti per la preparazione dei modelli 3D di elementi modulari decorativi "bricks & tiles" in argilla la cui successiva prototipazione avverrà tramite fresatura dello stampo con pantografo CNC a 3 assi. Il workshop darà quindi ai partecipanti i fondamenti per l’utilizzo di tale strumento di fabbricazione digitale e si concluderà con la fabbricazione di un proprio modello realizzato durante il corso.
[more info]
[Press Kit]…
ding is not for the faint of heart and is quite a significant understanding. However, I don't know what your dealing with, so that may be the way to go about it.
Your component if its "finished" has to supply some sort of results that are then used downstream. AFAIK there isn't a way to "prevent" down stream components from calculating until your finished. They have to get some sort of information or else they'll just be waiting. Considering how the results of those components are likely to be invalid until the information gets calculated, it may be better off supplying them with nulls until you have some actual information to give them.
Anyway, I think that you should think very closely about the structure of your routine, and specifically how it will interact and update itself. The way I'm thinking about it now is that there really isn't anything that's done in the "solve instance" function if you will. Essentially the "solve instance" function would either A) start the reading of the file if no data is found, or B) output some data if it is found. This is an extreme undersimplification, but the simpler you keep this the more likely this will work. Here are a few more "details", i guess, of how I could see this potentially working...
Thread A - Initial call to Solve Instance function
+ Check and see if there are any results that exist from reading your file - at this point there shouldn't be. These results should be stored in some sort of class variable that is accessible to both threads. It might also be a good idea to have some boolean flag that will also be accessible that represents whether your reading/writing those variables.
+ Fire a function in another thread that begins the read process. Note that you'll likely have to do this through a delegate and an invoke call, but I'm not 100% sure
+ Fill in some null values for the variables you must supply
+ Output the nulls, thus finishing the Solve Instance function
Thread B - File Read Function running in separate thread
+ Open up the file. Note that its probably a good idea just to pass the file path (as a string) between the different threads. Leave the creation of the file/text stream to the one thread that's using it.
+ Perform all the necessary reading from the file
+ Copy all your data to the variables that are accessible to both threads.
+ Expire either the solution on either the component in question or (at last resort) the whole canvas. I know expiring the whole canvas is defenitely possible, but it should be possible to just expire the one component that's doing the reading.
Thread A - "Second" call to Solve Instance after being manually expired
+ Check and see if there are any results that exist from reading your file, which there now should be.
+ Output those shared results
+ Clear the last results (or cache them in some way) so that the next time the Solve Instance function is fired, you don't find any results and reread the file.
I think there are a few variations to this that could happen too, including having a separate function for reading and writing through the data that's called using its own delegate/invoke call to make sure that its extra safe.
If you haven't already, you should really look into event driven programming, delegates, and asyncronous messaging. These are going to be the 3 things that you'll need to have a decent hold on to make sure this things works. Just to let you know, debugging these things can be a bitch.…
ght on why this is, and some ideas I have for how to improve things going forward.
MeshMachine grew out of some scripts I started developing over 3 years ago (described here), originally just with the aim of achieving approximately equal edge lengths on a smooth closed triangulated mesh.
As time went on, I kept adding things, such as ways of keeping boundaries and sharp edges fixed, different ways of controlling edge lengths that vary across the surface, and different ways of pulling to surfaces.
I was also still experimenting with different rules for the core remeshing operations, such as valence driven vs angle driven edge flips.
All of these things meant many variables in the script. I wanted to share the work so others could play with it, but not really knowing exactly what people might use it for made it difficult to simplify the interface, so I just exposed most of these variables I was using (actually there were originally even more, but I felt a component with 20+ inputs was excessive, and combined some of them and fixed others to default values).
I've never been happy with that component, but some people want a component that you can just feed a surface and get a mesh with 'nice' triangles, without too much fuss or needing to know anything about how it works, while other people want to be able to vary the density based on proximity to the border, and curvature, and attractor points and see the intermediate results, and model minimal surfaces without pulling to any underlying surface, and...
Since then I did the rewrite from Kangaroo to Kangaroo2, and through that process, and associated conversations with Steve Baer, David Rutten and Will Pearson, my ideas about how to structure libraries and make cleaner more flexible Grasshopper components changed. Much of this centres around using interfaces (in the specific programming sense, not to be confused with UI), because they allow separating code into multiple components, while still allowing to edit parts of it within Grasshopper, and other parts in a proper IDE (because I find the GH code editor is not conducive to writing large amounts of well structured object oriented code).
Towards the end of last year, Dave Stasiuk and Anders Deleuran invited me and Will Pearson over to CITA for a few days of mesh and physics coding and beer drinking. During this time I made the first steps to restructuring MeshMachine to be more modular and interface based like Kangaroo2, instead of one giant script. One of the main motivations for doing this was to make it easier to combine the K2 physics library with the remeshing. However, at the time I hadn't yet released K2, so it didn't make sense to post examples that used those libraries. After the launch of K2, this restructured MeshMachine development has been a bit on the back-burner, but this discussion and Dave Stasiuk's work with Cocoon is inspiring me to pick it up again.
Seeing how you are combining the Cocoon and MeshMachine, and how Dave is also using interfaces in his recent work suggests to me it might be possible to integrate them more smoothly...
…