Add your entries to the Best Houdini Utility Category to this thread before the contest deadline.

Hi everyone! This one was inspired by one of the cool lattice methods used by Simon Verstraete's Sci-fi Panel Generator video on youtube.
Good for bending and deforming panels in an artist friendly way or tweak wood pieces.
The idea was to create a lattice tool that could deform objects with a profile ramp from a chosen direction.

To use its pretty easy:
1. input complex geometry like say the pigs head, or a bunch of polygon mesh objects.
2. place points on the profile ramp to change the deformation on the lattice
3. turn on the guide geometry for a visualization of the bounds /divisions of the lattice
4. Turn on 2nd ramp, or set thresholds/offset to limit where the deformation can occur.
5. Blend out half of the deform only works on the first ramp
6. With Interpolation set to bezier houdini doesnt let you have more than 30 divisions. So watch out for that... Linear Interpolation is more useful for hardsurface panel deform looks.


Lattices are just great for making quick variations and I feel ramp profile parameters speed up the workflow somewhat so thats why I made it. First time making a help card was fun. I used these labs tools inside my HDA- Labs Color Gradient, Labs Symmetrize, Labs Dissolve Flat Edges, Labs Voxel Mesh.

There are lots of examples in the hip file i included. Thanks for looking... excited to see what everyone else comes up with!

Hello everyone! I am pleased to share a utility that combines my love for digital painting, 2D animation and Houdini. Hpaint allows the user to draw paint strokes as quad; The idea is to have a similar experience to that of something like photoshop/toon-boom, with all of the added benefits of being able to use your strokes like you would any other geometry in Houdini. There is also functionality to use or ghost hpaint strokes that are time-dependent, allowing for multiframe animation.

Since this tool is so Python-heavy, I've also attempted to comment as much code as possible to help this tool become a little more educational in helping others understand viewer states and how SideFX' stroke functionality makes prototyping/implementing these kinds of tools really fun. I've also kept a changelog and some gifs for use-cases on github. [github.com]

Thanks for taking the time to have a look!

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

Glad I saw this challenge early this month because I took this opportunity to make this tool
For easier workflow, this HDA will allow to enter a viewer state and assign any group type within a single node.
Main features:
* Assign multiple groups with interactive viewer state
* Interactively see the selection based on a normal angle for primitive groups
* Convert point, primitive groups to attribute
* Automatically transfer previous group parameter values to the next one
* hotkeys for easier group management within a viewport
* Normal cusp angle set with a hotkey within a viewport
Edit: Just wanted to add that tool currently is only python 3 supported

Hey everyone,
I am proud to present my HDA for this challenge:
Linked Subnets
They are something I would have loved to use in some earlier productions. I extended the functionality of subnetworks which allows you to connect them together and share parameters and the contained nodes.
This greatly reduces the need to copy paste setups within the same scene. After updating one Linked Subnet you are able to copy your changes to other Linked Subnets with the push of a button.
Linked Subnets can be compared to HDAs but you can even use them for very specific node trees that only make sense in one scene without cluttering up your HDA folders.
They are especially useful when you have to create a similar setup for many inputs while keeping it art-directable. Also, you are able to easily add or remove nodes and parameters when it is required while also propagating those changes through your whole node tree.




Features:

1. Copy Nodes and Parameters
   
2. Keep individual parameter changes per instance
   
3. Art-Directable
   
4. Keep individual parameter changes per instance
   
5. Python 2 and 3 support
   

Enjoy

Hi!

This is my entry to the Houdini Utility category:

Color Sampler

Description
Sampling colors is usually done by manually clicking on an image or the screen, one color at a time.
The Color Sampler asset can automatically sample multiple colors from an image/screen.
Points are generated over the image/screen and then each point samples the color of the nearest pixel.
The colors are then stored in a color ramp.
Manually sampling by drawing on the image/screen is also possible.
It also allows modifying the colors in various ways and the colors can be exported for use in other applications.

Features

• Sample pixel colors by drawing or generating points on the image/screen and store the sampled colors in a ramp.
  
• Resize and blur the image.
  
• Sample all pixels between two or more points.
  
• Snap points to pixels.
  
• Sample raw or filtered (interpolated) colors.
  
• Sample unique colors.
  
• Sample the most frequent (or dominant) colors by grouping them by similarity or by counting the occurrences of each color.
  
• Draw on the screen: manually draw points on one or more screens. Inspect pixels by showing color values, pixel coordinates and sample count next to the cursor. Enable/disable/remove strokes.
  
• Draw in the viewport: manually draw points in the viewport to sample the image/screen. Resample and enable/disable/remove strokes.
  
• Line sampling: use points on one or more lines to sample the image/screen. Set the line positions using local space coordinates or pixel coordinates which allows for exact positioning, rotate the lines and extend the lines to the image/screen bounds.
  
• Grid sampling: use points on a grid or sample every nth pixel of the image/screen.
  
• Random sampling: use randomly distributed points to sample the image/screen.
  
• Input sampling: use points connected to the input pin of the node to sample the image/screen or keep the existing point colors.
  
• Get the average sample color and average image color.
  
• Sort colors by hue/saturation/value/brightness.
  
• Compare colors using "Lab Delta E CIE94", hue, saturation or value/brightness and remove colors that differ less than a specified value.
  
• Override the sampled colors by setting/adding/multiplying the hue, saturation or value/brightness.
  
• Translate all of the colors in the ramp and optionally repeat the positions at the start/end of the ramp.
  
• Apply noise to the position of each color in the ramp.
  
• Scroll through the colors in the ramp.
  
• Display samples in the viewport as points/nulls/circles/planes/boxes and as color swatches.
  
• Set the sample size to the pixel size.
  
• Set the image transparency and filter: "linear" for smoothed colors when zoomed in or "nearest" for a pixelated look.
  
• Set the max number of colors that can be stored in the ramp, shown in the viewport and output from the node.
  
• Export the colors to an image: either as the swatches shown in the viewport or as they are shown in the color ramp. Set the image size and the number of pixels per color.
  
• Export the colors to a JSON text file: store the colors as float values, integer values or hex values and with a color ID.
  
• Fully documented parameters.
  
• Node type: SOP
  

Use cases

• Link the color ramp to other ramps to apply the colors to textures or geometry.
  
• Create color themes.
  
• Modify existing point colors.
  
• Export the colors for use in other applications.
  

Version: 2.8
Date: 29 September 2021

Description
Detect the frame at which attribute reaches given conditions. Then create and store attributes on points:
• @startframe attribute corresponding to the frame the change occurs.
• @triggered attribute corresponding to based on point's state.
‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎If @startframe's value match current frame, @triggered is set to 1.
• @id attribute sorted by point's start frame.
• Node Type: SOP.

Features
• Condition to reach to trigger computation
• Visualizer for @startframe, @triggered and @id attribute.
• Dynamic label that return simulation data (@startframe of the first and last point to be computed).

Use cases
• Synchronize animations or simulations(drive switches, trigger simulations one after another,...).
• Get additional data from animation or simulation (@startframe can be used to determine age, life, contamination speed, ...)

Node Features

Some Examples
A quick video showing some use cases of the Startframe Solver in Houdini.

Description
• Create Turntable Setup for Look dev.
• Chrome / Matte Ball Overlay on camera or free stand.
• Rotate Model / Lights / Cameras

Features
• Rotation
‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎- Model, Camera, or Light just by connecting the node to it.
‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎- 360° Rotation based on playbar's frame range.
• Spheres Layout:
‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎- Compact: Chrome / Matte Ball side by side
‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎- Vertical: Chrome / Matte Ball above the other
‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎- Realistic: Chrome / Matte Ball with Stand asset.
• Transform:
‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎- Compact / Vertical: Position left / right, rotation and scale
‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎- Realistic: Transform / Rotation / Scale
• Color Chart: Optional Color chart
• Backplate
‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎- Procedural Backplate
‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎- Created only on-camera frustum, avoiding blocking light.
‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎- Backplate from any angle
• Shading:
‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‏‏‎ ‎‎- Materials assignment for the asset (balls, chart, stand, and backplate)

Use Cases
• Create quick turntable
• Avoid recreating setup each time
• No need for a dedicated scene.

Demo
A quick demo of the features of the node.

SuperShapes
SuperShapes makes simple work of creating common and not-so-common 2-D shapes using Johan Gielis's superformula equation. The asset provides a well-documented, user-friendly interface for artists to quickly add 22 predefined shapes to their scene as filled or unfilled polygons. Each shape offers additional control over the look of the shape, allowing for surprising variety. There are built-in convenience options for basic extrusion, beveling, and triangulation and UV's are automatically calculated for filled curves and 3-D meshes.



In addition to shape presets, the "Playground" shape option provides an interface for visually experimenting with the superformula equation, for artists to create their own original shapes. SuperShapes strives to be a simple utility for making art in Houdini.

Hey All!

I'm glad to present my asset for creating clothes.

Description

It seems to me that making a complex pattern is today's main problem of creating clothes in houdini. The current method for sewing different pieces of a pattern with vellum drape requires the same number of points on the seams.
There is an excellent planar patch node, which implements the ability to set the number of points on the edges of the shape, which is exactly what is needed for correct seams. But with it, we can only create incredible rectangles, trapezoids and circles, while clothing patterns are quite complex shapes.
So I decided to try to improve the situation with the patterns a little)

Features

• Pairwise resampling of curves to meet the requirements of vellum drape
  
• Selecting seams with python state
  
• Automatic sending of seams to vellum drape
  
• Visualization of future seams using guides
  

Use cases

- Creating complex clothing patterns

------------------------------------------------------------------------------
Hope it will be useful to someone.

https://www.sidefx.com/forum/topic/80721/ [www.sidefx.com] - WIP is located here, most likely, I will post updates there
https://drive.google.com/drive/folders/1AKDi5CcHTWVIwrdr7h71RDpNOkUoZOKa?usp=sharing [drive.google.com] - more examples
The video below is in Russian, there are subtitles

Hi

Wanted to contribute to this challenge

Description
A missing feature ive allways wanted in houdini was the possibility to cut curves with shapes.
So here it is!
Plug your curves in input number one, and your mesh in input number two




Features
It cut curves with a closed mesh.
It keeps your attributes and interpolates them



Use cases
If you have some curves, and want to cut them. Use the curve cutter.
If you have a nice weave of curves, and want a hole for your button. Use the curve cutter.

Hello !
Happy to participate here with all this talented artists !

Divide Equally
Divide polygonal geometry into multiple pieces fairly distributed based on XYZ spacing, or numbers, of subdivisions specified.
Specificity here is that distribution is done from an manually or automatically oriented bounding box.

Polygons are properly divided without generate unshared edges but can also be sliced.

Multiple island of polygon can be divided independently with their oriented bounding box for each one. Island are evaluated by connectivity of input or group selection if any.

Fast Remesh

DESCRIPTION:
Based on the original Remesh Sop, but way more performant thanks to multithreading, it also comes with some quality of life features for a simpler and safer remeshing.

HOW IT WORKS:
Fast Remesh splits the input geometry into pieces and remeshes each piece in parallel inside a compiled for-loop.
After remeshing, the pieces are merged back together and the topology around the seams is cleaned, if needed.

USE CASES:

• Abusive-remeshing workflows (example: a recursive chain of displace&remeshing, like shown in the video)
  
• Any interactive creative workflow where you need to remesh your model to millions of polys in a bunch of seconds instead of waiting for minutes.
  
• Mass remeshing of separate objects
  
• Wedging scenarios where you need a constant ratio of remeshing
  

Key Features

• Generally 8x-12x faster than Remesh Sop, peaking at 25.5x in some scenarios (measured on a 24cores machine)
  
• Set the desired Target Polycount for the output geometry (0.8-0.99 accuracy)
  
• Set a Polycount Emergency Limit with auto-clamping to avoid doomsday remeshing tasks.
  
• Customizable Presets of Multipliers buttons for the Polycount and the Average Edge Length of the input geometry.
  
• Dynamic mode toggle for wedging workflows: any incoming geometry can have its polycount doubled (tripled, etc), instead of a fixed value.
  
• Identifies pieces by: fast clustering, connectivity, custom attribute, UV Island.
  
• Preserves UVs. No broken textures.
  
• Post-remeshing operations to clean the topology and "hide" the seams of the pieces.
  
• A lot of debugging attributes like "Polycount Estimate Accuracy", "Polycount I/O delta", etc
  
  

Mesh Cutter

DESCRIPTION:
Tool for fast mesh cutting. Add it to the scene, hit enter, and cut your models freely.

HOW IT WORKS:
Mesh cutter records curve strokes made by the user, find the geometry center and thickness, and cut it through using boolean SOP.

FEATURES:

• Multiple cut types (razor, curve, detailed) with numerous tweaking options
  
• Additional Split by part SOP that helps to split cutting geometry for further cutting
  
• Radial menu functionality that helps to cut your meshes even faster
  
• Simplified mesh cutting for a more interactive experience
  
• Build-in UV mapping of the cuts
  
• Automatic merging of the split parts
  
• Freezing option for selection perseverance
  
• Constraints generation and tweaking
  
• Compatibility with RBD tools
  
• Debugging options
  

Rough overview


New features



-

Hi everyone,

My submission is a Polyline Creation Utility. It's to be used as an input for a lot of spline related generators. It supports intersections and custom attributes per point. It could be used for many things, for example road networks, racetracks, plants, pipe generators... basically anything polyline based. The custom attributes help with setting up complex UI, for example if the banking of a road should be editable, if there should be fences etc.

This can also be used in combination with Houdini Engine and Session Sync. In the example of a racetrack generator, this could be really practical for fast iterations while keeping complex control.


WIP Thread [www.sidefx.com]

Curve Intersection

Description:
Solves curve-curve intersections with convenient snapping options.
To efficiently deal with the intersection and snapping logic, this iteration of the node projects the input curves onto XZ Plane. This is something that I'd like to revisit in the future.

Attached are examples of what can be built with this.


Features:

• Performant curve/curve intersection on a 2D plane
  
• Snapping of curves to one another, including to intermediate intersections
  
• Optimization of incoming curves without losing fidelity while speeding up computation a lot
  
• Dynamic detection of corners based on angle threshold
  
• Attribute Transfer for Points and Primitives
  
• Post-projection on input collision mesh
  

Use cases:
Any time something is built upon input curves that either intersect or have to join up.
This could be roads, cities, walls, defining areas to scatter vegetation and much more!

EDIT: Fixed some typos and added demo .hip file

Hello there, ​I'm not quite finished with this tool, but for the sake of submission here it goes!


HDR Workbench is meant to be an easy to use set of tools to create environment maps to light your scenes with. With the flexibility of procedural workflows, you can not only create your HDR environment maps, but animate them for even more creative effects.

Feature list:

• Built-in procedural light plane objects with shape, color and intensity controls;
  
• Light planes can be texture mapped to match studio lighting equipment;
  
• Rasterizer coded in VEX (no need to bake with Mantra);
  
• Link output from rasterizer directly to environment light using op: syntax;
  
• Layer your HDRI on a background map using COPs, inside the rasterizer;
  

You can download the assets and example file here:
https://www.sidefx.com/forum/attachment/60a3a56b039cb5ecdea810fdff9fee8b801352c6/ [www.sidefx.com]
https://www.sidefx.com/forum/attachment/9701bd931ab490946b184f20b2e28662d032849e/ [www.sidefx.com]

This is a link to Perfect 3D Imperfection's store, where I got the image in my demo:
https://www.artstation.com/perfect3dimperfections/store [www.artstation.com]