This is the actual reason I'm going through all this. I want to develop an algorithm that can be applied consistently and produce good results.
Here is a a little background. I'm working on my master's thesis in structural analysis. My thesis is on seismic behaviour of a roman temple in Portugal. I will be using a method of analysis suitable for block structures called the discrete element method. I am using a commercial code called 3DEC for this.
Now in order to the analysis I need to construct a 3D block model of my structure. I received a 3D scan of the entire structure (in *.wrl) format and spent a week trying to clean it up and slice it into the blocks that make up the structure. Now I want to use the scanned geometry of the blocks and describe a simplified prism around each that will represent the block in my analysis. I've attached a file with one of the columns in the temple. I think (at least with my tests so far) that it is representative of the all the blocks I'm dealing with.
Now my criteria for creation of the blocks:
I would like the contact area between the blocks to be as close as possible to the actual drum contact area,
I would like to get the volume of the blocks to be as close as possible (secondary to the contact area) to the volume of the actual drums in order to insure that the weight distribution in the structure is as close to reality as possible,
I would like the shape of the contact area to be as close to reality as possible
I order to satisfy all these requirements, I've done the following in my grasshopper file:
I take a section at the top and bottom of each of the drum meshes. I use this to extract the contact outline at the top and bottom of the drum. This is sometimes problematic and requires me to clean up the model and remove features that interfere.
Next I take each surface and try to fit a minimum circle around it. I try to do this because in my mind this is the best possible way to find the actual centre of the drum when there is cut outs and deterioration. This works well as long as more than half of the contact surface is still in its circular shape (third block from bottom in the example file doesn't satisfy this requirement and thus causes problems).
Knowing the centre, I use an algorithm I created in VB to search for one of the flutes on the contact profile. My ideas is that if I can find one of the flutes, I can then find the others by just going around at 30 degrees (there are 12 flutes) and find the location of all the flutes. In the VB code I've tried to explain my algorithm so I won't explain it here. I also think this algorithm is needlessly complicated and stupid as I'll explain later.
Once I've got one of the flutes, I just find the intersection of a line with at every 30 degrees with the outline curve.
Having all (12) points around the perimeter, I use an loop to scale the shape around the centre of the circle I found in step 1 to get the area within a tolerance value of the actual contact area (satisfying requirement 1). I was using HoopSnake before, but it required resetting every time so I decided to write my own thing.
I then connect the points on both top and bottom to get a solid block.
Now the problems are as follows:
Sometimes the algorithm doesn't find the best location as the starting point. As I said an important thing is that the circle is tangent to the flutes and that is true only if the column profile is larger than a half-circle.
The software I use requires convex blocks. I've tried to remedy this by using convex hull component before step 5 to insure the surfaces are convex.
I'm having issues sometimes with the alignment of top and bottom points. I think I just need to implement a component that sorts the points around a single basis so that there is no twisting.
I've been experimenting with convex hull as a general approach for defining the corner points, but I'm having problem take the convex hull curve and breaking it into a 12 sided polygon, preserving as much as possible the location of the flutes and the general shape of the contact surface.
I'm really sorry about the long post and complicated question. I hope someone can give some pointers on what I could try. I understand that this is not an easy question and that it is more a question of doing something rather than asking about grasshopper itself. My goal is to have an algorithm that I can explain as a general method for others to use in the future when dealing with these structures. This is only a small minor part of my thesis (the analysis is what is important) but it is taking a lot of time to figure out.
If you have any other questions, I would be more than happy to provide a better explanation. In the file I have created a region with all my input parameters. You can choose a different mesh from that point and change various settings. I hope that is self-explanatory.
Thanks for all your help,
Ali
BTW: I'm really sorry for the poor way I've done this stuff so far. I'm not a programmer and apart from some small macros in Excel I don't know much about this stuff. To add to that, I've just started with Rhino and Grasshopper about five days ago after almost pulling out all my hair trying to do this with AutoCAD!…
What is it?Bumblebee is a set of user objects which connect Microsoft Excel and Grasshopper.
The current component set allows for not just the transfer of data back and forth between GH and XL but giv
rsistant data , as the inputs and outputs of the component should be build by the data stored in the object.
thanxs in advance
Michael
here is the code of the object....
public class Proxy { public List<string> _name_in; public List<string> _name_out; public List<SerializableType> _type_in; public List<SerializableType> _type_out; public List<GH_ParamAccess> _access_in; public string _path; public string _script; public bool _internalized; public bool _working; public Proxy(List<string> name_in, List<string> name_out, List<SerializableType> type_in, List<SerializableType> type_out, List<GH_ParamAccess> access_in, string path, string script, bool internalized) { _name_in = name_in; _name_out = name_out; _type_in = type_in; _type_out = type_out; _access_in = access_in; _path = path; _script = script; _internalized = internalized; _working = true; } public Proxy() { _name_in = new List<string>(); _name_out = new List<string>(); _type_in = new List<SerializableType>(); _type_out = new List<SerializableType>(); _access_in = new List<GH_ParamAccess>(); _path = get_path_of_plugin(); _script = ""; _internalized = false; _working = false; } public static string get_path_of_plugin() { string temp_cut; string string_path = System.Reflection.Assembly.GetExecutingAssembly().Location; string string_name = System.Reflection.Assembly.GetExecutingAssembly().GetName().Name; int temp_name_int = string_name.Length + 5; int temp_path_int = string_path.Length; temp_cut = string_path.Remove(temp_path_int - temp_name_int); return temp_cut; } public static T ObjectDeserializer<T>(string XmlInput) { System.Xml.XmlDocument XmlDoc = new System.Xml.XmlDocument(); XmlDoc.Load(new System.IO.StringReader(XmlInput)); System.Xml.Serialization.XmlSerializer ser = new System.Xml.Serialization.XmlSerializer(typeof(T)); T out_ob = (T)ser.Deserialize(new System.IO.StringReader(XmlInput)); return out_ob; } public static string ObjectSerializer<T>(T SerializedObject) { System.Xml.Serialization.XmlSerializer ser = new System.Xml.Serialization.XmlSerializer(typeof(T)); System.Text.StringBuilder builder = new System.Text.StringBuilder(); XmlWriter xmllol = XmlWriter.Create(builder); ser.Serialize(xmllol, SerializedObject); return builder.ToString(); } } public class SerializableType { private Type type; // when serializing, store as a string // [DataMember] public string TypeString { get { if (type == null) return null; return type.FullName; } set { if (value == null) type = null; else { type = Type.GetType(value); } } } public Type return_Type() { return type; } // constructors public SerializableType() { type = null; } public SerializableType(Type t) { type = t; } // allow SerializableType to implicitly be converted to and from System.Type static public implicit operator Type(SerializableType stype) { return stype.type; } static public implicit operator SerializableType(Type t) { return new SerializableType(t); } // overload the == and != operators public static bool operator ==(SerializableType a, SerializableType b) { // If both are null, or both are same instance, return true. if (System.Object.ReferenceEquals(a, b)) { return true; } // If one is null, but not both, return false. if (((object)a == null) || ((object)b == null)) { return false; } // Return true if the fields match: return a.type == b.type; } public static bool operator !=(SerializableType a, SerializableType b) { return !(a == b); } // we don't need to overload operators between SerializableType and System.Type because we already enabled them to implicitly convert public override int GetHashCode() { return type.GetHashCode(); } // overload the .Equals method public override bool Equals(System.Object obj) { // If parameter is null return false. if (obj == null) { return false; } // If parameter cannot be cast to SerializableType return false. SerializableType p = obj as SerializableType; if ((System.Object)p == null) { return false; } // Return true if the fields match: return (type == p.type); } public bool Equals(SerializableType p) { // If parameter is null return false: if ((object)p == null) { return false; } // Return true if the fields match: return (type == p.type); } } public class GH_Proxy : Grasshopper.Kernel.Types.GH_Goo<Proxy> { public override Grasshopper.Kernel.Types.IGH_Goo Duplicate() { return this; } public override bool IsValid { get { return true; } } public override string ToString() { return Proxy.ObjectSerializer<Proxy>(this.Value); } public override string TypeDescription { get { return "his is a proxy"; } } public override string TypeName { get { return "his is a proxy"; } } }…
ome work to create a ZScript macro for custom routines, but you can record those in ZBrush and then merely need to edit them into my script, inline, as bulk multiple-lines you just paste in, no problem as long as you strip the ZBrush button definition at the beginning.
ZBrush has a very high initial learning curve because of its non-standard interface. However, it has the world's most powerful quad remeshing and now mesh Booleans too. I needed a replacement for slow and especially non-robust marching cubes (Cocoon/Monolith/Dodo/Aether etc. on Grasshopper) that tended to bog down or blow up. IntraLattice was a step in a good direction but it can't merge fattened lines that merely cross each other with no breaks or that physically overlap on purpose to have many curve on in to a hub. But with $800 ZBrush 4R8, the latest version, that I can create English language ZScripts for, I suddenly have, often in the blink of an eye, or at worst a few seconds, right back into Rhino Grasshopper, a perfectly joined, airtight and smoothed mesh blending of upwards of thousands of input mesh pieces that overlap in ways Rhino will never Boolean union.
There is no complicated installation of anything since it's all done in Python.
The ZBrush program itself pops up while it works, and is then automatically backgrounded to bring you back to Grasshopper. It keeps running though, for fast iterations with no program startup time.
This is a general toolkit to expose myriad very advanced features of ZBrush into being just another Grasshopper plug-in like the rest.
It works by accepting a Grasshopper mesh and writing it to disk as an OBJ file, then incorporates ZBrush settings for a given command into a text format ZScript file, also written to disk from Python based on Grasshopper inputs, then ZBrush is told to run the script via Windows command line, and the exported OBJ output is read back from disk back into a Rhino Grasshopper mesh, in about a hundred lines of code.
Despite a change in mesh definition in Rhinocommon from version 5 to 6, I made it work on both versions.
So far this is only one command, the newly improved mesh Boolean union. It gives quad meshes, but they still look healthy when quickly triangulated in Rhino (as seen on top, above).
The ZBrush ZRemesher is utterly astounding in ability to transform any mesh into a direction following, error free quad mesh that can be converted to NURBS actually, via T-Splines smooth mode. That will be the next port to Grasshopper. I hope architects pick up on this more orderly manner of patterning surfaces than the alien slime of random point Voronoi.
Commercial software has the best code, not open source stuff, so far, so this is serious work to bring world class tools into Grasshopper where we can rapidly prototype computational strategies.
Here is a thread with several examples of ZBrush Boolean union remeshing applied to 3D trusses, compared to both IntraLattice and marching cubes:
http://www.grasshopper3d.com/forum/topics/custom-unit-cell-bug-in-intralattice-plug-in?commentId=2985220%3AComment%3A1828609
The same strategy of generating script files I used to port OpenFlipper, here, for triangle remeshing, which can now be combined with ZBrush Boolean unions of arbitrary assemblies of mesh units:
http://www.grasshopper3d.com/forum/topics/best-uniform-remesher-for-patterning-organic-suraces
UPDATE: I revamped the workflow so now components feed raw ZScript into a sequencer. Then only a single ZScript is assembled and sent to ZBrush so Python never gets ahead of ZBrush (!):
It is easy to DIY roll your own now:
…
Added by Nik Willmore at 6:48am on October 12, 2017
u might already noticed.
Second great thing is that is quite fast, precise and versatile (for this kind of things); also is way OPEN (meaning you can attach and or interface it with almost anything you can imagine, meaning hardware, and other sw components, etc (like a CNC machine (additive manufacturing toys..) or any sw like C# component)) making a GREAT HUGE difference with almost any other CAD (and CAM sw i must say)
i made a simple fully functional CAM component - highly powerful ! - in a couple of days...
also tested an arduino interface (meaning control over almost any elctronic device out there)... in a matter of hours...
and saw and can easily think about lots and lots of extremely cool usages of this great tool in almost any area ...
So that's why i would suggest - and will do something about for - it (or similar tools) to be teached at first stages of education !
But power comes with responsability. and is far better exploited when your are smart ;)
I think people that uses GH will be n-times as good when they don`t forget manufacturing.
This includes teachers btw....
Interesting thing to account is that all things that GH is great at (a LOT) means reducing dramatically the time spent to model almost anything...
But usually the purpose (unless the objective is just learning or doing some kind of virtual art (both legal stuff btw...;) but guess it might not be your case now and after graduating..)) is to end up by actually building some real 3D stuff...
So what Joseph is poining is key...
If you have a good teacher.. i guess it should pay more and more attention not just at your gh skills but rather the way in which you use the power, versatility and extra time gh (and additive manufacturing tech) saves, to think about how to design the stuff focusing on the ultimately relevant stuff...
optimisation...
So..
I would say that any heat interchanger like the one involved in your thesis, has to deal with fluids.. have to account for some sort of life span (involving cheaper an ideally no maintenance needed along its life...), and of course also critical the costs of manufacturing.
so... be the best one...
use GH smartly ! ie...
account for different profile paths for oil and water.. they're different fluids meaning they have different specific heat, viscosity, blah... and so... they might not even traverse the interchanger at same flow ratio, etc.
So... maybe you want to start by reshaping the grid... (parametrically...!) so you can arbitrarily and dynamically modify and get to see interactively in your definition the areas ratio of sections so as to finaly get to set the "ideal" (meainng optimum) relative areas (sections) ratio of oil to water paths... (or whatever other fluids could be !), and the material also...
Secondly you might also consider that triangles might not be well suited for the conduit sections because are not the best shape to carry most fluids... (hoses are of circular sections...worst case are kinda rectangular with rounded corners..;) not only because the're easy to manufacture but also because they minimise (optimize) flowing energy losses AND are less prone to (ie salt or debree deposits in the interior) ). so think about rounded shapes, of if you want some regular polygons stuff but 5 or more faces...kinda circular...got it ?
I love bees by the way..
and if you happen to need more interchange area (obviously another (and probably the #1 key one) figure you should be displaying interactively in your definition ) you can always add some more extrusion length...
third... the twisting stuff is cool... (artistically ;)) but i 100% agree with Joseph is far likely to involve higer costs for manufacturing with no clear benefit on surface maximization... and most probably some other losses in added friction to the flow of fluids (meaning higher costs for pumping, etc...)...
fourth...
consider the area, (then the volume!) of the "building material"... you should optimise that too ! so this could be another one of your interactive displays...
in this case... you not only can see optimisation by reducing the amount of materials to build your interchanger...
but you can also notice that if the "building tech" involves the well and common additive manufacturing process of extrusion deposits... that surface area, and that extrusion length, meaning volume and cost of raw material, also mean TIME to manufacture... and i guess you teacher will find good for you to consider and mention that one too...
fifth...
finally (for now hehe), and globally most important in the short term :)
if the objective of yor teacher is for you just to learn GH and impress him and the rest of the world then, ok, do the twist the swirl and imagine all kind of sea star and or ondulated conduit sections (maybe some recursive forms (fractals...) like snowflakes... or any n-arms (mutant !) starfishes shapes) but make sure you first get to know and validate what it will be the objectives of your evaluator...
.. in the near end this is all about passing your thesis while learning GH while having fun.. isn't it ?
go for it and best of luck !
ps: for the mid and long term.. some day take a look at linear optimisaton if you already didn't.
i think GH is a great tool to try out some linear optimisation stuff directly linking geometry related figures (areas, volumes...) along with costs figures !...
I haven't seen anything like that yet (but since i'm only a few months old in gh, i think is likely to already be something or this stuff out there. )
If not... well you can always be the first !
(and this particular case of your thesis is a great example (few key variables) to try out "automatic optimisation")
https://en.wikipedia.org/wiki/Simplex_algorithm
that... by the way...has lots to do with spatial geometry...
…
ere I'm using a GH_ObjectWrapper type. This may not be the best way about doing this, but it does work.
localSettings of type EM_Settings is the data that gets wrapped and then added to the Parameter.
Whilst everything works fine first time around, when I re-open the GH file the persistent data is lost. I need to serialize the data in some way in order to write it to a GH file and I'm not entirely sure how to do this.... I've tried for quite a while now, looking through the forum & SDK which offer clues but no joy... so I'm admitting defeat and running here!!!
Here are some of the CS bits:
public class MyComponent : GH_Component { ......... private EM_SettingsParam myParam;
private EM_Settings localSettings;
private EM_Settings mySettings;
protected override void RegisterInputParams(GH_Component.GH_InputParamManager pm) {
... myParam = new EM_SettingsParam(); EM_Settings localSettings = new EM_Settings(); myParam.PersistentData.Append(new GH_ObjectWrapper(localSettings)); pm.AddParameter(myParam, "Settings", "Se", "MySettings", GH_ParamAccess.item); }
protected override void SolveInstance(IGH_DataAccess DA) { GH_ObjectWrapper temp = new GH_ObjectWrapper(); if (!DA.GetData(5, ref temp)){ return; } mySettings = (EM_Settings)temp.Value;
...
} } public class EM_SettingsParam : GH_PersistentParam<GH_ObjectWrapper> { public EM_SettingsParam(): base(new GH_InstanceDescription("Settings", "Settings", "Represents a collection of Settings", "Params", "Primitive")) { } ...blah singular blah plural blah exposure.hidden blah... } public class EM_Settings { public bool Preview {get; set;} // (more parameters here) public EM_Settings() { Preview = true; }
}
Any help much appreciated $:)
John.…
URBS cup surface, and boy oh boy did it ever work more uniformly than using 3D orb cutters on a 3D cup. Different sized spheres return the *same* hex grid only less and less raised up as the spheres get very large.
My first question is whether these are different in character or just in Z scaling, so if I rescale them all to the same Z thickness, after extracting only the relief structure via Boolean union and splitting...and they are only *slightly* different in character, which means mere Z re-scaling of a single moderate ball size relief is an appropriate cheat to avoid slow Boolean union re-making each relief Z scale with different sized balls.
The one on the right is a very shallow relief scaled up to the same Z thickness as the pure sphere one on the left. And really, we will be mostly scaling *down* from a thicker master surface so that will attenuate any weirdness in the curvature. Indeed, I see no difference, so it makes sense to only archive the thickest one so we can control the full range of thicknesses, all the way to nearly flat bulbs. Here is the thickest one, just before the balls lose holes between them, scaled down compared to a shallow one made with huge balls to start with:
Now we just use Rhino Flow Along Surface or the Grasshopper Jackalope plug-in Sporf to morph this flat system onto our lathe form.
With Rhino history for the Flow Along Surface step I can rescale the original in Z and wait twenty seconds to see the update:
There are sad edge artifacts that will require some strategy to retain or later delete a whole row:
Maybe add more geometry to later delete or make a solid to hold stuff together?
So vastly decreasing the cell count and changing grid direction to match your cup:
The edges came out fine on this one, happily. The isocurve count has been increased by the Flow Along Surface command:
It can't be filleted yet since the joint where the cup NURBS surface has a joint now leaves feathery edges, so I went back and duplicated the border of the flat array, offset and lofted to make a protecting surface:
But that gave crazy artifacts:
I'm just going to use symmetry to fill in the joint with good faces that are not having to be joined as two halves. I had to turn my Rhino units tolerance down from a silly 0.0001 to 0.01 units to get a good re-join, but it still won't fillet without leaving holes.
SO LET'S FILLET THE FLAT THING. Same problem but a bit faster, and actually repairable manually. Rhino 5 is buggy as hell with core commands, damn it. This is not world class behavior.
Let's try it in Rhino 6 WIP, our great hope of the future: nope, the same. I had to simply manually copy the missing pieces from where it did work, which at least is easy to do in flatland. Now I get a cup:
This can *all* be done quickly in Rhino without Grasshopper, and Rhino affords you fast cage editing of the original flat array that Grasshopper cannot yet do. You just need to use Analyze Direction to be able to swap UV directions of the source or target and flip the source surface to achieve concave vs. convex patterns.
Grasshopper doesn't even have a fillet (multiple) edges component so there's not a lot of advantage to having some super slow parametric system via Grasshopper. It's not like you'll be able to see the changes fast enough to tweak a design.…