Branch Joints - part 4

Tree Multi Joint Complex New by nick.sullivan.now on Sketchfab

Each branch now has a unique value based on it's intersection with the other branches in the joint, giving much more natural look compared to the previous version Branch Joint - part 3. This approach also gives much more artistic control over the joint construction, allowing refinement of each joint based various attributes such as per branch, generation and joint.

Branch Joints - part 3

Tree Multi Joint Complex by nick.sullivan.now on Sketchfab

Finally got the joint intersection calculations done, this means that branch joints are dynamically generated based on the intersecting geometry. Quite a complex network was employed to enable this functionality, lots of  ForEach nodes.

Branch Joints - part 2

Tree Multi Joint by nick.sullivan.now on Sketchfab

Branch Joints - part 1

Branching joints is a topic I've been interested in for a while. In researching this area I've read a variety of techniques, each having interesting ideas in their own right but not altogether robust solutions for my needs.

Recently I came across a great article which presents a pro/cons and comparison of the various techniques, then presents a different and more robust branch joint solution. Basically the key realisation is that the problem can be boiled down to 2 main areas convex hull construction and subdivision loop method.

Procedural Tree Generation: Modelling Branching Structures as Subdivision Surfaces

The following proof of concept demonstrates a trivial case for performing branching joints

In order to test the join process, firstly copying Tubes of various size and resolution to Tetrahedron points resulting in the above geometry

The tubes are Mesh geometry not polygons, this allows to carve off the end edge loops

Number simply illustrate that each has different point counts

 Tetrahedralize SOP is used to generate a convex hull geometry

The convex hull creates geometry superfluous to need, which can be rectified by taking the dot product of the primitive normals of the convex hull source geometry and convex hull itself

Geometry can be removed where it satisfies certain criteria produced by the dot product

Merging tubes with convex hull, perform cleaning with PolyDoctor SOP correct winding of polygons and creating vertex normals

Finally a Subdivision SOP using the method of OpenSubDiv Loop generates the best results, others cause rippling effects

Polygon Curve Carving

After finding that the Carve SOP doesn't allow the use of attributes, thought I'd give making my own version that handles custom attributes and parameter expressions. Currently for my purposes I only need to carve polygon curves, so it shouldn't be too difficult. Later I might tackle other curve types, nurbs, bezier. If all goes well and I have the time, I would like to try surface carving but it might out of reach.

To define the polygon curve carve tool for development, I started by analysing the workings of Houdini's native Carve SOP. Firstly, there's quite a significant difference in the way it handles polygons v nurbs curves. In short the poly curve carving implementation is basically a case of removing and positioning points, where as with nurbs it's quite a different story, involving a number of high order concepts, eg. Knot insertion, corner cutting, interpolation etc.

I generally begin by nutting out the implementation detail, when developing any tool. This process helps break down a problem into manageable pieces and involves lots of sketching, working through scenarios to build an idea of how the carve tool in this case should operate.

POLYCARVE DIGITAL ASSET HIP
Version	1.0.0
Build	14.0.361

Python hou.runVex()

In a previous post I managed to find and implement the math required to find intersection point between 2 lines in 3D, which was interesting and a challenge.But in that and other situation I often wonder how I can exploit Houdini more when it comes to this kind of math, as Houdini's nodes already implement so much. Quite commonly cases arise where I'd like to run some python code against a node, ie. Invoke a node, pass some geometry and return the output.

That's where I got to thinking that VEX actually has a lot of powerful functions that Houdini's python doesn't, Then I remembered coming across the hou.runVex() method. After spending the best part of a week getting to grips with this workflow, thought I'd write down some of my findings, since there's not much out there on this topic.

Things of note when using hou.runVex(vexfile, inputs)

1. The inputs argument can't be an empty dictionary, even if there aren't arguments defined on the cvex function.
2. I've found that cvex must be the context function, at least when working with the Python SOP. Although don't quote me on that needs more testing.
3. When compiling, it's safest to rename the .vfl when changes are made, at least for a successful compilation to vex. e.g.. Say you have a file named attrib.vfl and you compile it to attrib.vex successfully, upon making code changes to the .vfl it's safer to rename the file attrib_01.vfl and compile this to a corresponding .vex file. This will ensure that the vex file reflects the changes.
4. There's conditions to passing lists or arrays in the inputs dictionary, they must have the same length and each lists items must be of the same type.
5. Also related to input arguments having length > 1 , e.g. Lists or arrays. Theses types will affect the exports/bound variables length, causing outputs to also display matching length even when their default value is of a single value.
6. Another point worth noting regarding inputs when using lists is that they effectively form a kind of loop, running the vex code as many times as there are items in the list. This ability could be utilised to emulate functionality akin to the vex/vop nodes parameter run over : points, prims, vertices, detail.
7. It also seems, a least for vector type inputs, they must be contained in a list or array type, ie When passing a single vector, it will need to be in an list of 1 item, or the function's input argument default defined in vex will be used. This doesn't seem to be the case with strings or integers, which makes me wonder whether it's due to vector types having native length in it's components.
8. This point needs more testing, getting some very strange results which are difficult to track down.I think there is a memory issue, although it could be due to way vex works! Not entirely sure. Can't recall exactly, but in the docs it talks about how vex is compiled and that it doesn't allow for recursive code. One odd effect of running vex via Python in this way, is that you can refer to the returned value before you've made the call. eg

          
     print a
     a = hou.runVex()
   
     This will work fine!
     Then again it doesn't, as it shouldn't.
     
    

   I think there maybe a memory related issue, because although the vex is running as expected, it seems to store the result in memory and that's why the above call to variable "a" before it's definition works, occasionally. Now when I change position values via an upstream transform node, the results of the vex also transform when they definitely shouldn't be. The kicker is when I save the hip with the upstream xform and reopen the hip the results are as expected. Also the variable ref that was working now doesn't, errors as expected. which brings me back to the vex in memory being the problem.

In Short, It works! Mostly.
As long as the above points are considered, hou.runVex() should work as expected. This workflow has the potential to be very helpful and powerful, which I'd like to use more often. Though the last point is a bit of a concern.

Intersection Point of 2 lines in 3D

After spending some time researching ray tracing implementation and solving simultaneous equations, I had the feeling there should be vector formulation to this problem. Anyway since I'm not a mathematician I wasn't going to easily happen upon the answer by myself. As it happens The vector form of the solution did exist and I was able to find it at the following links.

The Math Forum : Vector Algebra - Finding the Intersection Point

Math Stack Exchange : Find intersection of two 3D lines

As this work is related to a broader set of tools I'm developing, the code is implemented in python. Although the same could be done in VEX or VOPS.