Attachments:
Lattice profile shape.jpg (183.0 KB)
Lattice Profile Shape examples and unlocked hda .hiplc (2.2 MB)
joze.Lattice_profile_Shape.3.0.hdalc (139.2 KB)

Attachments:
aaron_smith__hpaint__1_1.hdalc (383.6 KB)
hpaint_example_scene.hiplc (2.1 MB)
hpaint_test_v008_comp_v003_smallB.jpg (1.3 MB)

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

Attachments:
EHA.UTIL_PolySlice.1.1.hda (260.0 KB)
PolySlice_v1_1.hip (1.1 MB)
PolySlice_MainLogo_New3.png (565.9 KB)

Attachments:
multigroups_img.png (1.1 MB)
multigroups.zip (48.5 KB)

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

Attachments:
appleDemo.v04.gif (7.1 MB)
LEO.linkedsubnet.1.1.hdalc (51.4 KB)
linked_subnet_render_v004.hiplc (2.9 MB)
linkedSubnetDemo.hiplc (476.5 KB)
linked_subnet_render_v004.v001.jpg (651.0 KB)

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

Attachments:
color_sampler_2.8.jpg (653.2 KB)
techie_color_sampler_2.8.hda (225.1 KB)
color_sampler_examples.hip (1.2 MB)

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.

Attachments:
000-examples.hiplc (2.5 MB)
startframe_solver__0_11.hdalc (41.6 KB)
ex1-thumb.jpg (230.0 KB)

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.

Attachments:
turntable__0_11.hdalc (142.1 KB)
000-example.hiplc (563.0 KB)
thumb.png (1.6 MB)

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.

Attachments:
tearsheet.png (119.7 KB)
SuperShapes_Render.jpg (1.7 MB)
supershapes_example_scene.hiplc (614.2 KB)
joenyc.SuperShapes.1.0.hdalc (268.0 KB)

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

Attachments:
ap_pattern_prep.hdanc (49.2 KB)
dress_example.hipnc (9.1 MB)

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.

Attachments:
curve_cutter.hiplc (329.8 KB)
redux__curve_cutter.hdalc (13.4 KB)
CurveCutter.gif (556.8 KB)

Attachments:
Divide_Equally_1.0.png (3.4 MB)
divide_equally_example.hiplc (610.3 KB)
VertiTool.divideequally.1.0.hdalc (254.5 KB)

Attachments:
Fast_Remesh_Asset_and_Examples.rar (432.6 KB)

Attachments:
mesh_cutter.zip (6.6 MB)

Attachments:
util_polyline_creator.PNG (661.2 KB)
util_polyline_creator.hdalc (90.4 KB)
polyline_creator_demo.hiplc (621.4 KB)

Attachments:
intersectionfree_002.png (72.0 KB)
intersectionfree_001.gif (1.4 MB)
knolls_curveintersection-1.0.0.hdanc (62.9 KB)
knolls_curveintersection_demo.hipnc (725.3 KB)
advanced_example_001.gif (8.6 MB)

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]

Attachments:
houdini_5JFGz0414W.png (938.5 KB)
houdini_63hNMVgtbO.png (1.3 MB)
houdini_BFml1bdrih.png (633.7 KB)
main.hdr_workbench.1.0.hdalc (66.1 KB)
hdr_workbench_example.hiplc (795.1 KB)