konstantin magnus

Seriously though, to bake point colors onto a UV texture, set a string parameter to your geometry and put these lines into a COP snippet. vector pos_tex = set(X, Y, 0.0); vector geo_clr = uvsample(geo, 'Cd', 'uv', pos_tex); assign(R, G, B, geo_color); baking.hipnc

Once you have laid out your model properly a mere fuse node will do. Here is a quick attempt to get you started. It still lacks orienting the handle to the holes, though. cup.hipnc

Also here is a short video tutorial in case you still wonder how it's done:

And here is a slightly simplified variant for those who prefer using VOPs. curve_art_VOP.hipnc

Let's suppose we want to imitate graffiti art pieces with minimal effort. Warp the lines into curvy curves. Map the direction to the closest curves with greyscale values. Colorize each segment. And e x p l o d e by color difference. curve_art.hipnc

Hi Helmut, I got fairly good results by distorting colorful circles on top of images/renderings like so: https://forums.odforce.net/topic/44391-na/?tab=comments#comment-208974 To get closer to certain artists' way of painting though you would need to breakdown their visual style first. There won't be the one uber-cartoon shader that covers it all. Hirai Toyokazu also used to present his cartoon shading workflows on CMIVFX. Maybe you can get hold of this: https://web.archive.org/web/20180827020108/https://cmivfx.com/houdini-cartoon-effect

Hi Jiri, to get started I just wrote a script that turns a bunch of lines with three points into circles: It's basically calculating the intersection point and radius of rectangular vectors starting from the lines' midpoints. To be run in a primitive wrangle: // 3D INTERSECTION // https://stackoverflow.com/questions/10551555/need-an-algorithm-for-3d-vectors-intersection function vector intersection(vector r1, r2, e1, e2){ float u = dot(e1, e2); float t1 = dot(r2 - r1, e1); float t2 = dot(r2 - r1, e2); float d1 = (t1 - u * t2) / (1 - u * u); float d2 = (t2 - u * t1) / (u * u - 1); vector p1 = r1 + e1 * d1; vector p2 = r2 + e2 * d2; vector pos_center = (p1 + p2) * 0.5; return pos_center; } // INPUT POSITIONS int pt_0 = primpoint(0, i@primnum, 0); int pt_1 = primpoint(0, i@primnum, 1); int pt_2 = primpoint(0, i@primnum, 2); vector pos_A = point(0, 'P', pt_0); vector pos_B = point(0, 'P', pt_1); vector pos_C = point(0, 'P', pt_2); vector mid_AB = (pos_A + pos_B) * 0.5; vector mid_BC = (pos_B + pos_C) * 0.5; // DIRECTIONS vector dir_BA = normalize(pos_B - pos_A); vector dir_BC = normalize(pos_B - pos_C); vector dir_rect = normalize(cross(dir_BA, dir_BC)); vector dir_BA_rect = normalize(cross(dir_BA, dir_rect)); vector dir_BC_rect = normalize(cross(dir_BC, dir_rect)); // ADD CIRCLE vector pos_center = intersection(mid_AB, mid_BC, dir_BA_rect, dir_BC_rect); float radius = distance(pos_center, pos_A); int pt_add = addpoint(0, pos_center); int circle_add = addprim(0, 'circle', pt_add); matrix3 xform_circle = dihedral({0,0,1}, dir_rect); scale(xform_circle, radius); setprimintrinsic(0, 'transform', circle_add, xform_circle); // REMOVE INPUT GEOMETRY removeprim(0, i@primnum, 1); circles_from_points.hipnc

You can manipulate the viewport shader by pressing the 'D' key with your cursor on the viewport. In the "material" tab you will find the typical settings.

Hi Zunder, I think the second video you have posted shows almost the entire process: He is basically deforming a spiraling grid.. flower.hipnc

Hi Andy, if you don't get an answer here, it's mostly because you did not specify your question sufficiently.

In order to turn voxel fields into cubic meshes first make sure their interior is filled. Then set the VBD visualize tree node to 'Active Voxels' -> ''Solid Boxes'. Then again use boolean union and dissolve inner edges. voxel_mesh.hipnc

Hi Nicola, @moedeldiho from Entagma recently published a tutorial about moving points along gradients: https://entagma.com/obstacle-avoidance-flow-fields/ I quickly turned it into a 3D variant, although I am pretty sure this could also be done within volumes or POPs. tears.hipnc

Hi Felix, first you would iterate over all neighbours() with foreach(), adding all dot products of the point's and the neighbors' normals. Then you divide this sum by the number of its neighbors. // INPUT float thresh = chf('threshold'); // PROCESS float d = 0.0; int nbs[] = neighbours(0, i@ptnum); foreach(int nb; nbs){ vector nml_nb = point(0, 'N', nb); d += dot(v@N, nml_nb); } d /= len(nbs); // OUTPUT f@acuteness = d; i@group_acute = thresh > d; v@Cd = hsvtorgb(set(1.0 - d,1,1)); There is a a bit on curvature and the likes in the documentation about the new measure SOP: https://www.sidefx.com/docs/houdini/nodes/sop/measure.html acuteness.hipnc

If you need the result in SOPs it's probably more performant and convenient to just stay in SOPs. So you would move the tracing procedure from the COP's canvas to a SOP's grid and use findattribval() to check which primitives have been hit, like so: SOP_trace_prim_IDs.hipnc