Custom Unit Cell Bug in IntraLattice Plug-In

Replies to This Discussion

Permalink Reply by Nik Willmore on October 10, 2017 at 6:30am

In hindsight, this feature of a custom unit cell seems sort of trivial to just whip up in Grasshopper in a bounding box, then to trim the lines with the mesh or brep and cull any shorts. Rhino/Grasshopper lack a trim with mesh command though, so an intersection, shatter, and test for inclusion of midpoints is perhaps needed, which may be terribly slow. Argh, there isn't even a split command for curves, just shatter that needs a parameter, since Rhinocommon doesn't expose its real split command to programmers.

Permalink Reply by Nik Willmore on October 10, 2017 at 9:25am

Alas, I'm having a mesh inclusion bug ruin the long winded trim routine.

Permalink Reply by David Stasiuk on October 10, 2017 at 9:04am

Both Mesh.IsPointInside() and Curve.Split() work fine for me.

Permalink Reply by Nik Willmore on October 10, 2017 at 9:24am

I have isolated bug behavior here, for a simple mesh:

Attachments:

• Mesh Inclusion Bug.gh, 12 KB

Permalink Reply by David Stasiuk on October 10, 2017 at 10:20am

Ah, looks like this is a result of how the inclusion is always calculated. Basically, a line interesects the mesh from the point to an arbitrary point outside of the mesh: if the number of strikes is even (0, 2, 4) then that means the point either never hit it, or went in and out again, meaning it's outside. If it hits an odd number of times, then it must have come from within originally.

The method implements this approach using the mesh bounding box, and then striking a polyline from your test point along a vector that is defined by the upper right corner of the bounding box + a vector of (100,100,100). In the case of your failing points, this is a result of their striking an edge very precisely, which gets counted as 2 hits instead of 1 (as it should be getting captured) and passing false:

Your best bet is probably to roll your own implementation, that tests for multiple vectors:

private void RunScript(List<Point3d> P, Mesh M, ref object A, ref object B, ref object C)
{

BoundingBox bb = M.GetBoundingBox(false);

List<bool> inside = new List<bool>();

for (int i = 0; i < P.Count; i++)
{

Polyline a = new Polyline();
Polyline b = new Polyline();

a.Add(P[i]);
b.Add(P[i]);

a.Add(bb.Max + new Vector3d(100, 100, 100));
b.Add(bb.Max + new Vector3d(100, 150, 150));

int[] fa;
int[] fb;

Point3d[] xa = Rhino.Geometry.Intersect.Intersection.MeshPolyline(M, new PolylineCurve(a), out fa);
Point3d[] xb = Rhino.Geometry.Intersect.Intersection.MeshPolyline(M, new PolylineCurve(b), out fb);

inside.Add(xa.Length % 2 == 1 || xb.Length % 2 == 1);

checkA.AddRange(xa, new GH_Path(i));
checkB.AddRange(xb, new GH_Path(i));

}

A = inside;

}

Permalink Reply by Nik Willmore on October 10, 2017 at 2:43pm

A bug in a rug, and homework too, thanks! Yes, I noticed the geometry pattern. 

Permalink Reply by Nik Willmore on October 10, 2017 at 3:33pm

Python version:

Rhinocommon needs to be updated. My account won't work on Discourse.McNeel.com, nor will a fresh account with a new email address. Says it's temporarily locked out for weeks now.

Attachments:

• Mesh Inclusion Bug B.gh, 8 KB

Permalink Reply by David Stasiuk on October 10, 2017 at 4:07pm

I've pinged them on Discourse that it's still failing in certain cases.

Permalink Reply by Nik Willmore on October 10, 2017 at 4:17pm

Here is a spaghetti mess first stab at a working IntraLattice custom unit cell script:

However, this won't work with IntraLattice, since it errors out when two co-linear lines are not joined together into a polyline. It will expand a single line or even kinky polyline just fine, in the later case by adding convex hull hubs between them. But I think it tries to do the same thing for co-linear lines and then gets a flat self-overlapping mesh as the convex hull hub that can't be joined to the struts.

When I just array a unit cell, it's not obvious how to join lines only in appropriate pairs, while not also joining inner co-linear lines that need to stay split at inner hubs. Even with its own unit cell system, when it works to array the cells, bad meshes result in the middle of struts.

It already takes ~6 seconds, without some great search for exactly two size hubs that need to be joined into a non-hub.

A kludge option: modify my unit cell before making an array, to extend lines outside of it into all adjacent cells, then cull any that touch the super bounding box, then array and cull duplicate lines since they are now dual-cell lines coming from both sides of each cell pair. This way I only have to strategically avoid joining in a single unit cell, to only join where lines touch the cell. Even that is a logistical puzzle, worth much spaghetti.

Attachments:

• Intralattice C DIY CUSTOM UNIT CELL ARRAY.gh, 50 KB

Permalink Reply by Nik Willmore on October 10, 2017 at 7:14pm

Validating my quest to learn Rhinocommon with Python, all that spaghetti is gone, as I could not for hours of work figure out any combination of grafting, simplification and flattening to get past a single case of a line having two intersections with the mesh. That mismatched my data trees, fatally. When one branch has two items in it instead of one, and a component refuses to let me graft the final branches of a tree with a simple flat list, then it's just game over for spaghetti.

It astounds me too that the simple Rhino command to split a bunch of curves with a bunch of points is not in Grasshopper because it's not even exposed in Rhinocommon. I'm back in kindergarden when that sort of 101 stuff is missing.

I haven't handled multiple intersections of lines/polylines with the mesh to have to split a given line twice or more, but that's a rare case and means I have to re-learn enumerables list Windows data format to do the Rhinocommon command right.

Next, to join lines to remove "hubs" with only two struts, though I should check co-linearity to, to allow polyline bends in unit cells.

Attachments:

• Intralattice E Python Enhanced.gh, 56 KB

Permalink Reply by Nik Willmore on October 10, 2017 at 9:10pm

The trick to finding the lone pairs of strut lines was Grasshopper Cull Duplicates because it also outputs the valence of each final point, how many times it appears, so if you isolate the valence two points after making a list of all endpoints of your line collection, you can then use Python to readily loop through each of those lone pair points to gather pairs of curves attached to each point, join them, and then delete the original pair.

In order to generalize to curves I may merely need to convert them to polylines within the unit cell since the Rhinocommon mesh intersection command uses a polyline. There is no mesh/curve intersection command.

Attachments:

• Intralattice F Python Enhanced.gh, 57 KB

Permalink Reply by Nik Willmore on October 10, 2017 at 9:34pm

...indeed, if I remove my intermediary Grasshopper line nodes from between the clusters, and I use Rhino to convert a unit cell curve into a polyline, it works fine:

It's not desirable how oddly it gives a more crude mesh of anti-prisms where my polyline has less curvature. That means I can't smooth via single subdivision to an even mesh unless I remesh the whole thing.

Attachments:

• Intralattice G Curves As Polylines.gh, 55 KB

• ‹ Previous
• 1
• 2
• Next ›
• Page