weimarser
How can this plugin support Houdini 18.5 Version?

The original builds of the Poly Slice may work for H18.5 ... Though I'm not sure if version 1.0 through 1.3 were tested on that.

But the current official version, released with LABS with 19.5 should only be used on that version and above.
Perhaps Houdini 19.0 may work, but I did notice it does not work properly on Houdini 18.0 or 18.5 due to vex script changes missing in older versions of Houdini.

Now releasing the V1.3 PolySlice

--------------------------------------------



--------------------------------------------

See the attached file :

New Poly Split v1.3 features:

I noticed there was a big demand to cut complex cuts into larger and denser surfaces.
But the original PolySplit method was not always suitable for this due to its slower processing speed.
So I integrated a new cutting method using the Boolean Shatter,
So the tool now has two output methods for Surface to Surface Cutting, the PolySplit and the Boolean Shatter Cutting Methods.


- The PolySplit Method:

Is very versatile and can cut with polylines or surfaces.
It also supports snapping to make cutting surfaces easier with input curves that are provided procedurally to the Utility.
While it's slower, and not well suited to cut larger geometries, it excels at making very precise cuts for precision tasks.
And thanks to its polyline cutting feature, it can handle surface cuts that no other SOP in Houdini can handle.

- The Boolean Shatter Method:

This new method is much faster, very accurate and can cut shapes and edges into surfaces without touching the edge of the shape.
It automatically runs a cleaning pass on the boolean to ensure clean cuts, and supports the same features as the Polysplit method, like masked cutting.
While it, does not support snapping like the PolySplit method, it works great to cut large dense polygon meshes with surfaces.

- Auto Precision Limiter:

When dealing with very small or large geometry, some of Houdini's nodes become unstable.
The Auto Precision Limiter feature analyzes the input geometry provided to set some sensible limits on the tool.

Thank you for Third Place

I'm glad that the tool was recognized for its potential.
And I hope it, or a version of it, can find its way into the Labs Toolset or Houdini.

Under a different name perhaps alongside the H19 Polyslice that was just added .

I've got a few adjustments that I have to finish up for v1.3

And ofcourse, congratulations to the other winners

Thanks so much for 3rd Place



I'll try to finish up my adjustments on V1.3 this week and publish it here.

xopowoo
In HDA with multiple instances, the same instance is automatically integrated into one actor.
Is it possible to separate them individually?

Yes you can using a split instance attribute.

In my video here I show how it can be used:

https://youtu.be/-noDmzShkRM?t=3022 [youtu.be]

vinyvince
I also tried the high precision mode in your HDA but to my surprise result were worse. So for now, I'm afraid will stick with how i did before

I've not had much time to work on 1.3 since my last update. I'm going to try to get back to it this week.

The polyslice's main purpose is to allow for precision cuts. Like cutting floors, walls or curves and cleanly injecting points, For this, it works very well and at this resolution the snapping features work at their best.




The node works per primitive to inject points, and then performs a slice per affected primitive if required in a second stage. Because it runs per primitive, cutting high resolution geometry for this reason is slower.
I've also constrained the data I feed to the poly-split SOP to allow it to perform sequential cuts cleanly.


However, if set to a low snapping strength, the tiny segments that are created in corners and on near perpendicular edges are harder to keep clean. This is why I created the high precision mode preset. But even with that,its a tricky issue.
So as a result, slices like in your example picture really push the cutting capabilities to their limits.

You could probably get your above example with a VDB to polygon tube shape, and then use a boolean to cut out the overlap with the original mesh.

Also I notice that in the example picture you seem to have set the Poly-slice into Poly line mode as your input source; because every cut is output as a polygon edge... Which won't give you the result you are looking for either way...
Maybe you did this to visualize the issue better ?




In the the end though...

The Poly slice's main purpose isn't to replicate the Boolean sops raw speed and cutting capabilities.
But to create specific, precise cuts, such as on many of the low res cases in the example file.

The high resolution cutting of complex surfaces like in your picture is slower and more sensitive to errors, because the lowered snapping strength and tolerances make the final result less predictable. It could run into tiny cuts that are below the snapping precision of some of the component nodes, like the intersect stitch, or the poly-slice itself and this is a hard limit where the node becomes more prone to errors.

I'm working on making cutting like this more reliable.
But I won't be able to make it any faster, at least, not without overhauling the node for this specific purpose or creating an alternative cutting method in the asset...

So basically, the Poly-Slice works best with higher snapping strength and tolerance values to guide the cutting behavior, so it avoids creating these tiny cuts altogether.

Andr
For now I'll use Boolean, but eventually I'd like to use your tool, as I need to perform this kind of operation on 3D surfaces, not simple planes, and also I need some reliability with coinciding borders, which, I if understand well, your tool already have.

The Polyslice tries to snap cuts to edges, if a cut overlaps (parallel) to an edge it will either ignore it or insert points.
The main issue is the tolerances and the scale of primitives and density of the elements used to cut.
If the snapping/tolerance is set strong enough, the snapping feature will simply snap cuts to edges which often ensures clean cuts. But at higher strength this may result in undesired snapping if the cuts are very dense in detail.

The lower the snapping distance/strength, the more precise the tolerances have to be to compensate to make correct cuts.
However, at a certain scale the Poly Split SOP and the Intersect Stitch SOP both start losing accuracy. The Boolean SOP can deal with a higher degree of precision but there are still limits.

Due to these inherent limitations with the default sops in Houdini, the tool needs to be configured to work at the scale of the geometry you are cutting and the resolution of the cutting geometry, so the snapping and cutting precision needs to be set accordingly.

I'm working on a V 1.3 and I've managed to make your example work well enough, however I still need to make sure my alterations can scale, so it will be a few more days before I can release this version.

Andr
I'm also testing Polyslice with some high-res polyline cutter, like shown in the image.
I can't get it work properly: it seems to skip some cuts.
Would you please have a look at the attached example file and see if I set it up correctly?

cheers

There are two main problems I found.

1 - An issue with the level of precision, and that's something i'm trying to fix using your example. as some curves were not detected as being on an edge point or valid surface.


2 - When using High Precision mode, the tools snapping and detection range for intersections is greatly decreased.
This works fine with cutting surfaces, but not so well with splines. as a result the intersect stitch misses some intersections.
I'm going to build a limitation into the tool so high-precision mode won't be available when not cutting with surfaces. Or ill change the tolerances it sets.

Here below is a result as it stands now, but i'm still looking into it.
This kind of geometry intersection is probably still better when done with the boolean node as you showed in your picture. Because in the end your goal is to cut out the overlap at a cardinal angle, something the boolean is pretty much specialized in. However, I do want my asset to be able to tackle this kind of situation.

I'll work a bit more on this and get a new version out when I get a proper fix.

Andr
Hello Herwyn,
I'm experiencing a weird issue with 1.1

In some occasion it's weirdly slow: for example if I load up the example project you provided and I let cook one of the example, even a very simple one, the first time it would take quite a while (almost 1 second).
Now, if I disconnect all the inputs, and reconnect them, without changing any parm, the re-cook would take a breeze, like expected for such a simple geometry. Even when I move the input curve with a transform node, the cutting is real-time.
If I instead change the name of the polyslice node, it would cook again pretty SLOW.

Very weird issue.

I'm not sure, I've noticed this as well, but this may be due to the compiled network inside the node re-compiling and validating its code. Afterwards as long as the node remains unchanged the node is faster. You can try to disable the compiled toggle on the asset, it will slow down general cooking but will bypass the compiled code.

Here is the latest version of the Poly-slice.

Since the contest thread is now closed I will update it here.

Changelog - v1.2:

I fixed a bug which could crash the poly split sop in the asset when cutting consecutive cuts on the same primitive, if a secondary cut ended on the edge from a previous cut. In this specific situation the poly-split node could potentially be assigned the wrong primitive to cut. It should now properly assign the correct primitive.

Hello Everyone,

Here I present my entry to the Utility Challenge - The Poly Slice SOP.


Over the past few years I've been working on a masterclass for Houdini and one of the problems that I often ran into
is the general lack of a reliable methods to cut polygon surfaces, using a simple input curve, surface or even just a point.

Yes there are several nodes that do this to some extent, but they all have their issues.

• The Boolean SOP can cut Seams but requires an intersecting surface to do so and it has issues with coincident faces.
  
• The Intersect Stitch SOP can cut points into edges but lacks precision when doing so with surfaces, especially when not on a cardinal plane, and it can sometimes cause bad or unwanted triangulation.
  
• The Knife SOP lacks the ability to make fine cuts because it just cuts in an infinite slice.
  
• And the PolySplit while powerful, can only handle one cut at a time, and is designed to function with a handle in the interface. And I've found its alternate secondary input is not completely reliable.
  

As a result, these are often not flexible enough or require some form of wrapper or support structure to actually do what I need them to do.

Cut very specific edges and points into surfaces, using points, curves or cutting surfaces...
Without breaking, messing up my attributes or groups, over-cutting or creating bad geometry.

So I analysed and combined together the best of the above to create the PolySlice SOP



the latest version of the asset is v1.1

Feature list:

• This node can inject points or cut a polyline or surface, with a second point, line or surface.
  
• It can cut surfaces at any angle, it has no problems with non-cardinal angles.
  
• Group filters are supported for both the source geometry and the cutting geometry.
  
• It generates groups to mark points and edges that are newly cut.
  
• It works at various levels of precision and can snap the cutting input to the target geometry's edges or points as required.
  
• It can deal with coincident faces, so no zero space errors like with the boolean node and it cleans up overlapping cuts.
  
• It keeps Attributes and Groups intact and propagates them through.
  
• It can cusp the edges of Slices if enabled.
  

It works mainly by utilizing the capabilities of the Poly Split SOP and the Intersect Stitch SOP, but also features a lot of custom code to re-create and cut polygons when these nodes weren't viable.

To be clear, the cutting behavior of this node when cutting surfaces with one another, can be similar to a Boolean node in Intersect mode. In that sense, the Poly Slice is not a Boolean 2.0. In this specific niche, the Boolean SOP is still faster than the Poly Slice.

Instead, the Poly Slice carves its own niche, where it excels in its simplicity and flexibility.
Because of its ability to take multiple combinations of inputs and outputs, it is especially powerful when making procedural precision cuts on target geometry, or when point insertions are required. Something the Boolean SOP or any of the other cutting nodes are not able to do.


A form of this utility asset will be featured as part of my Houdini Masterclass in future installments of the course.
However, because of its usefulness, I hope the Poly Slice can become a part of the LABS toolkit.


Thank you for your consideration of my entry.

-------------------------------------------





- Erwin Heyms

A quick update, this evening I fixed the hole polygon issue as far as my tests have shown.
I'll do more testing to be certain it is fixed.




It basically has to identify every location a cut intersects with a double edge.
This is an edge where a hole polygon connects the inside and the outside of the single primitive surface.




The old method didn't keep this edge separated for the PolySplit SOP to identify so I could connect to the vertex on either side.
Which would result in this:




Now it does.

volodXYZ
Awesome work!
If I properly understood the description, a possible usecase would be interesting recursive greeble patterns(if used inside of a for each loop), similar to this unreleased tool by Simon Holmeda [youtu.be].

It can be used to recursively cut geometry, yes ​

Its one of the first reasons I created a tool like this.

Initially I used booleans, and this works well enough but only if you cut lines into a surface and this cut intersects with and to some extent overlaps the plane you are cutting.

I needed it to cut rooms into the floor shape of my building using curves:



The boolean method worked well for cutting walls into floors if both ends of the cut were in empty space, outside the mesh surface.

But its tends to over-cut or under-cut due to precision issues if you end it on an edge in the middle of your surface.
And sometimes, unpredictably doesn't even cut at all, if the surface is not flat or at a non-cardinal orientation.

Plus the boolean method simply lacks the ability to inject points on the edges of a mesh. The intersect stitch can do this but only works reliably on poly edges for similar reasons, it tends to fail on non cardinal surfaces :/


So the PolySlice Utility includes a snapping feature for edges and points to help ensure proper cuts.

It processes each primitive of the mesh separately in a step by step manner, cut by cut.
Which is required to make the PolySplit SOP work procedurally.

But it also ensures primitives are properly injected points before they are cut, so it always ends a cut on an edge and at its desired point positions.

The other issue with the native SOPS is that if you want to only inject points or make cuts in a complex 3D environment, it quickly runs into issues. Here is an example of an earlier version of the tool before I decided to remake it into its current form.

I built it to solve this specific problem, but this early version could only cut horizontally aligned surfaces.



I needed it to cut rooms adjacent to one another. If one room had a corner or a cut in the wall, the adjacent room also needed to have this.

Plus as you can see above, it had some other issues with hole polygons I wanted to avoid.

So I did some more testing of the nodes I was using, re-designed it to tackle each part of the cutting process separately.
To make sure it had more flexibility in what it can process and added more methods to control the cuts.

Hello everyone,

Over the past few years I've been working on a masterclass for Houdini and one of the problems that I often ran into
is the general lack of a reliable method to cut polygon surfaces using a simple input curve, surface or even just a point.

Yes there are several nodes that do this to some extent, but they all have their issues.

• The Boolean SOP can cut Seams but requires an intersecting surface to do so and it has serious issues with coincident faces.
  
• The Intersect Stitch SOP can cut points into edges but lacks precision when working with surfaces that are not on a cardinal plane.
  
• The Knife SOP lacks the ability to make fine cuts because it just cuts in an infinite slice.
  
• And the PolySplit while powerful, can only handle one cut at a time, and is designed to function with a handle in the interface.
  

None of these nodes are flexible enough and always require some form of wrapper or support structure to actually do what I needed them to do...

Cut very specific edges and points into surfaces using points, curves or cutting surfaces... without breaking, over-cutting or creating bad geometry.

So I analysed and combined together the best of the above to create the PolySlice SOP






Here is a list of features - UPDATED:

• This node can inject points or cut a polyline or surface, with a second point, line or surface.
  
• It can cut surfaces at any angle, it has no problems with non-cardinal angles.
  
• It ignores coincident faces, so no zero space errors like with the boolean node.
  
• It automatically cleans up overlapping cuts.
  
• It generates groups to mark points and edges that are newly cut.
  
• It work at various levels of precision and can Snap the cutting input to the target geometry's edges if required.
  
• It keeps Attributes and Groups intact and propagates them through.
  
• It can cusp the edges on cuts on if enabled.
  

It also includes a high precision mode, which presets the snap and cutting tolerances to work very well at cutting complex geometry at very fine sizes

It works mainly by utilizing the capabilities of the PolySplit SOP and the Intersect Stitch SOP.
I'm currently working on refining the tool, testing and cleaning up edge cases.
But it is especially powerful when precision cuts and or point insertions have to be made with a secondary input.

Some weaknesses of the node:

• Its slower than some other nodes when cutting surfaces, because the Poly Split is not compilable.
  
• Should be ran through a for-each loop per connected piece when dealing with intersecting masses of polygons because the non-connected intersection between these primitive surfaces can not always be properly resolved. - Solved
  
• It can't cut through the double edge connecting the inside and outside of a single hole polygon (still working on fixing this). - Solved
  

Here are a few GIF files to show it in action.

- This example shows how it can cut two complex polygon surfaces with one another.



- In this example you can see how we can using partial slices, but also layer slices to create multi-directional splits.
Even if they end in the middle of a primitive.



- This example shows how the snapping feature works to help cut up a cube, using a simple curve SOP as an input.



- Here the utility is in Curve mode, and is set to cut the curve using a polygon surface.

Hello all, I'm trying to find a way to spawn directly decal actors from the H-engine in UE4.
Since decal actors (and other default actors) are not assets from the asset browser but instead native actors, I'm not sure how to address them.

I've looked but can't find concrete documentation. Though I understand from changelogs I've read that this should theoretically be supported... ?

Likewise I imagine that I can set the material on the decal actor using the u_property attribute ?

Any information or guides on this?

Sincerely,
Erwin Heyms

This is directly related to the amount of nodes you are loading and the operations each node is performing on initialization.

When Houdini opens a scene, it caches all the nodes in the scene to memory and performs certain checks on the data.
It also bloats your memory footprint.


Every copy of a HDA gets this treatment, and as far as I'm aware you can't instance a node.

So either design your HDA to allow multiple birds to be spawned at once, or perhaps cache your data and then load it using a lightweight asset.

I'm not fully informed on all of Houdini's capabilities so I might missing more substantial that can help you.

+1 on this topic.

I just updated to Houdini 18.5 and also just noticed this.
I make a lot of use of this to debug, or provide feedback to the user. having to open the python shell to get information is annoying.

I'd like it to be able to output to the console on print like it has been able to.

Will V2 get access to fproperty attributes on unreal instances, so we can set different material instance settings per instance without having to instantiate entirely different meshes? at least If I understand it correctly the newest version of unreal allows for this.

I've been building a staircase tool and one thing I noticed that is a bit annoying is how I can't set negative scales to mirror a static mesh. When I try, the normals of the instanced mesh get inverted.



As a result I need to play tricks with my tileset to allow for as little amount of pieces as possible (because left and right winding can't always be flipped.

I can't however do this for my staircases, as an example I have a winding staircase set of 3 models in the clockwise direction.
But because I can't invert my mesh, I have 3 more for the counter-clockwise direction.



Strangely enough the Unreal Engine 4 does support inverted scale for meshes.
I can set the scale value of any static mesh to -1 and it will simply mirror itself, but its normals will remain intact.

I noticed how the meshes generated by the H engine are clumped together as instanced static meshes.
Is the inverted normals an issue with the import behavior from unreal or an oversight ?


Sincerely,
Erwin Heyms

Can also confirm, I get a crash on copying a HDA in UE4