konstantin magnus

Just compare both directions using the dot product: vector target = point(1, 'P', 0); vector dir = normalize(target - v@P); f@angle = dot(dir, v@N); target refers to the position of point 0 of the second input. dir contains the direction from each point of the mesh towards the target. angle compares the target direction with the surface normals, ranging from 1 (facing towards) to -1 (facing away). You can switch the wrangle to either points or primitives. facing.hipnc

Your file throws an error about SSS when I render. Have you tried setting the lens shader in shop context yet?

Good work! But a flat version of "Houdini Light" would be great, as well (like "Ash" but brighter). And maybe try to get rid of the dull orange you get when hovering over menus.

Good idea! I cleaned up our procedure a bit, so we basically have four stages: Input point cloud Rasterization Curve extraction Retransfer and connecting Inspired by this paper: http://www.iosrjournals.org/iosr-jmce/papers/RDME-Volume4/RDME-38.pdf It´s unexpectedly useful: you can jitter curves now quite a bit and still avoid overlappings: connect_pointcloud_to_curve.hipnc

And if you are ever dealing with a less organized point cloud you could abstract it with a grid before fitting a curve through. curve_through_pointcloud.hip

If the points string is evenly spaced and non-overlapping this combination works also on concave shapes: Connect adjacent points (from connect adjacent pieces-node) set to 3 search points and a sufficient radius Join node (only connected) Fuse @Noobini In your example above I think it would be sufficient to set the sort node to "vertex order" and leave out edgetransport. connect_string_points.hip

There are numerous threads about this I think, if you just google "houdini sort points radially", eg:

Use boolean union and dissolve inner edges found by 'max edge angle' in group node. only_outer_edges.hiplc

Extended it a bit: import os node = hou.pwd() dir = node.parm('directory').eval() msg = 'Directory {} does not exist'.format(dir) if os.path.exists(dir): msg = 'Directory {} exists.'.format(dir) elif not dir: msg = 'Choose a directory.' print msg

Just in case here is another procedural solution using heightfield conversion and booleans. height_lines.hip

Set up an empty VDB and activate it to define fixed dimensions. Optionally trim the point cloud to the volume´s size by using bounds and a group node. Then a volume wrangle maps the inverted distance of the closest point to each voxels density. points_to_fixed_volume.hip

To scale and rotate certain primitives take the group into a primitive wrangle: primpoints() and foreach() will process all points that are connected to the selected polygons instance() allows rotating and scaling around individual pivots. rotate() and quaternion() set up the orient attribute to be used in the instance() function. float amount = chf('amount') * M_PI; vector center = v@P; vector axis = prim_normal( 0, @primnum, vector(0.0) ); vector N = vector(0.0); vector rot_post = vector(0.0); vector scale = vector( chf('scale') ); matrix3 m_rot = ident(); rotate(m_rot, amount, axis); vector4 orient = quaternion(m_rot); matrix m = instance(center, N, scale, rot_post, orient, center); int prim_pts[] = primpoints(0, @primnum); foreach(int pt; prim_pts){ vector pos = point(0, 'P', pt); pos = pos * m; setpointattrib(0, 'P', pt, pos, 'set'); } prim_rot_scale.hip

Hi Jon, try "screen window x/y" for offsetting the camera.

Set a grid to 'columns' to create lots of vertical lines and randomize their scale and position with a primitive SOP. Group the tip points by their height beforehand and jitter or shift them outwards in relation to the center, like this: v@P += v@P * {1, 0, 1} * bend; A resample SOP set to 'subdivision curves' will bring the smoothness. grass_curves.hip

Here are two simple clipping tools using python SOP verbs: Bricker and Radial. Unlike the divide SOP it´s cutting always right through the center. python_cutting.hip