Grasshopper

algorithmic modeling for Rhino

Hey

I am attempting to panels similar to Tom Wiscombe's work so I can figure out how to depart from there. Anyway, my logic is to create horizontal strips and then create the vertical patterns and trim away; however, the trimming is where I am running into problems. 1. The lines are not are not synced and the trimming is not cooperating. 

I am currently working with large amounts of geometry when it would most likely be a better approach to deal with curves and intersections as opposed to heavy boolean operations. 

Here is an image of the project that is my inspiration. 

Thank you

Views: 2867

Attachments:

Replies to This Discussion

I would strongly suggest to trim the surface with appropriate u/v intervals (that's real-time).

Managing the intervals on the other hand is another animal (what "pairs" are already used). In fact I have somewhere (in some workstation, that is) a def that does this but is done solely with C#. It gives results the "easy way" (random "along" u or v but not both) similar with the Paneling tools equivalent component.

I'll try to find it and modify the "cull" logic in order to "fit" best with your goal. 

Peter,

Thank you for your reply. 'Divide and Conquer' looks like a menacing and formidable plugin and very well done.

As far as trimming with the proper UV coordinates, I assume you mean aligning the grid properly which I agree with, but did not pursue due to the late hour. Will try that now. I assumed managing and outlining the interval pattern would be a different approach from my destructive attempt.

Any suggestions on the proper intersection component/method to trim the horizontal surfaces or would it be better to keep both as culled grids and then somehow 'outline' and then create surfaces from them? I assumed working with surfaces would be best as I could then outline them, but I am not familiar with a technique to outline a group of them. Maybe it is just the wrong approach on my end.

Once again, I appreciate your response. Divide and Conquer is amazing !

Divide and Conquer: It's my favorite method in my practice: I put my people against each other and I pay them peanuts (how genius is this?).

PS: It's not a plug-in: it's made with some freaky language called C# (double click to the "component" in the def attached to see what I mean).

OK, jokes apart > back to our business (FORGET intersections and ANY bool thing > think ONLY (a) Intervals, (b) splitting a Surface with the right collections of Intervals):

1. See this attached: it's a prelude about dividing randomly surfaces in the forthcoming Div&Conq example n666. Notice that this deals with Intervals (although with rectangles but that's irrelevant). Notice also that's real-time. Accidentally splitting a surface deals with Intervals as well. Is this Karma? I don't think so,  he he

2. It does this by a method called recursive iteration: Erik calls Eric who calls Eric ... until some condition is satisfied (girlfriend waiting for dinner, for instance) and the thing stops.

3. I hear you: BUT that's not what I've asked for. Yes (the whole logic needs some rethinking) and No (it's "similar", he he).

4. I hear you: Where is the real thing? Good question, can I have the next please? It's the Nth time that I've lost something (Alzheimer most probably).

5. Definitely a brain like David Rutten can think a far more efficient/handsome/appropriate random u/v creation approach.

more soon

Attachments:

Since V1 actually works with the divide and conquer logic ("splits" recursively rectangles [but that is irrelevant, we can "split" Intervals and make an appropriate List to Split surface against them]) > I've started doing/thinking V2 > but we rather need David Rutten for "some" assistance on this 

Hi Peter, 

V1 is a very nice C# code. Thank you for sharing. It works nicely for random paneling. Nice Job! I worked on refining a definition for the irregular pattern paneling but realized it was too destructive and not parametric enough (many copies of the same operation) so I attempted enlisting Anemone to loop the patterns which were becoming too repetitive to be useful. 

Right now I just trimmed the panels in Rhino using GH to generate the surface curves, but the logic of the definition would be quite useful if I can figure out how to generate perpendicular pattern intervals more efficiently. Thank you for your thoughts and sharing your code again. I too will work on another attempt since Anemone was not working the way I intended. The hard (or rather cumbersome part) is making the patterns which require conditionals to work best. I will have another look in the morning and thank you once more for your extended explanations!

Divide and Conquer is a very useful tool! 

As I said from the very beginning the tricky thing here is to create the intervals. You need code for this not Anemone (for a myriad of reasons).

I'll give you the main one:

Ideally instead of wasting time to figure out some "genius" code that does the X interval mode (meaning that when the Y mode is required (other subdivision results, that is) > more code > play it again Sam > ...) we should MANUALLY interact with collections of Intervals and modify them on the fly.

This is doable only with code (it's a bit complicated to explain the reasons nor this is the right time to do it).

To give you the gist of this critical issue:

Forget for a moment our case: Imagine doing some cubes (boxes) and sampling them into some List/Tree. Now ... BEFORE ... storing any cube into the List I ask you to modify cube's size interactively (NOT using attractors et all: just modify the x/y/z values (or Box intervals) on a "per item" basis on the fly). Can you do it? 

I'll post something similar soon.

PS: converting V1 to work against Surf Lists/Trees random subdivisions is very easy (same principle just "replace" rectangles with Intervals) . I'll do it soon.

Great! Thanks again for the thoughtful response. I have a review Wednesday so I will get to work on your suggestions the following day. 

Thank you again for your insight. I will post my attempt as soon possible. Generating collections of cubes randomly dependent on input parameters is what I will attempt for these x intervals. I hadn't thought of starting with cubes. Makes sense as of now.  

RSS

About

Translate

Search

Videos

  • Add Videos
  • View All

© 2024   Created by Scott Davidson.   Powered by

Badges  |  Report an Issue  |  Terms of Service