SOP_CentroidDivide.C

Go to the documentation of this file.

/*
 * Copyright (c) 2022
 *      Side Effects Software Inc.  All rights reserved.
 *
 * Redistribution and use of Houdini Development Kit samples in source and
 * binary forms, with or without modification, are permitted provided that the
 * following conditions are met:
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. The name of Side Effects Software may not be used to endorse or
 *    promote products derived from this software without specific prior
 *    written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE `AS IS' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
 * NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *----------------------------------------------------------------------------
 * The HDK Centroid Divide
 */


#include "SOP_CentroidDivide.h"

// This is an automatically generated header file based on theDsFile, below,
// to provide SOP_CentroidDivideParms, an easy way to access parameter values from
// SOP_CentroidDivideVerb::cook with the correct type.
#include "SOP_CentroidDivide.proto.h"

#include <GA/GA_ElementWrangler.h>
#include <GA/GA_SplittableRange.h>
#include <GU/GU_Detail.h>
#include <PRM/PRM_TemplateBuilder.h>
#include <SYS/SYS_Math.h>
#include <UT/UT_DSOVersion.h>

using namespace UT::Literal;
using namespace HDK_Sample;

/// This is the internal name of the SOP type.
/// It isn't allowed to be the same as any other SOP's type name.
const UT_StringHolder SOP_CentroidDivide::theSOPTypeName("hdk_centroiddivide"_sh);

void
newSopOperator(OP_OperatorTable *table)
{
    OP_Operator *op =
        new OP_Operator(
                SOP_CentroidDivide::theSOPTypeName,     // Internal name
                "HDK Centroid Divide",                  // GUI name
                SOP_CentroidDivide::myConstructor,      // Op Constructr
                SOP_CentroidDivide::buildTemplates(),   // Parameter Definition
                1,                              // Min # of Inputs
                1,                              // Max # of Inputs
                nullptr,                        // Local variables
                0,                              // flags
                0,                              // custom input labels. See SOP_CentroidDivide::inputLabels instead.
                1,                              // 1 output
                "HDK Examples"                  // Set the tab menu category to "HDK Examples"
        );

    table->addOperator(op);
}

/// This is a multi-line raw string specifying the parameter interface
/// for this SOP.

// For our group parameter we will customize the string input parameter
// to more easily input the group.
// This group is on the second input. In SOP_Expand::buildTemplates
// we bind a drop down menu to the group field.
// Next, to get a selector button we use the 'script_action' parmtag to
// specify the script to execute when the button is pressed, the
// 'script_action_help' parmtag to create the hover tooltip, and the
// 'script_action_icon' parmtag to set the icon.
// All group selector buttons use the `soputils.selectGroupParm(kwargs)`
// function, and can use the kwargs['geometrytype'] to set the allowed
// geometry types, and the kwargs['indexindex'] to set the input
// to select on.
static const char *theDsFile = R"THEDSFILE(
{
    name        hdk_centroiddivide

    parm {
        name    "group"
        label   "Group"
        type    string
        default { "" }
        parmtag { "script_action" "import soputils\nkwargs['geometrytype'] = (hou.geometryType.Primitives,)\nkwargs['inputindex'] = 0\nsoputils.selectGroupParm(kwargs)" }
        parmtag { "script_action_help" "Select primitives from an available viewport." }
        parmtag { "script_action_icon" "BUTTONS_reselect" }
    }
}
)THEDSFILE";

PRM_Template *
SOP_CentroidDivide::buildTemplates()
{
    static PRM_TemplateBuilder templ("SOP_CentroidDivide.C"_sh, theDsFile);
    if (templ.justBuilt())
    {
        // Add drop down menu to the attribute string field.
        // The menu type is a PRM_ChoiceList and SOP_Node provides a
        // number of nice pre-built menus that you can use.

        // In this case we want to list all the primitive groups on the
        // second input. We can use SOP_Node::primGroupMenu to generate the
        // menu for us which will list all primitive groups.
        templ.setChoiceListPtr("group", &SOP_Node::primGroupMenu);
    }
    return templ.templates();
}

OP_Node *
SOP_CentroidDivide::myConstructor(
        OP_Network *net, const char *name, OP_Operator *entry)
{
    return new SOP_CentroidDivide(net, name, entry);
}

SOP_CentroidDivide::SOP_CentroidDivide(
        OP_Network *net, const char *name, OP_Operator *entry)
    : SOP_Node(net, name, entry)
{
}

SOP_CentroidDivide::~SOP_CentroidDivide()
{
}

OP_ERROR
SOP_CentroidDivide::cookMySop(OP_Context &context)
{
    return cookMyselfAsVerb(context);
}

// Set custom input labels for the source and destination inputs.
const char *
SOP_CentroidDivide::inputLabel(OP_InputIdx idx) const
{
    switch (idx)
    {
        case 0:
            return "Input Geometry";
        default:
            return "Invalid Source";
    }
}

// Define the verb for this SOP Node.
class SOP_CentroidDivideVerb : public SOP_NodeVerb
{
public:
    SOP_CentroidDivideVerb() {}
    ~SOP_CentroidDivideVerb() override {}

    SOP_NodeParms *allocParms() const override { return new SOP_CentroidDivideParms(); }

    UT_StringHolder name() const override { return SOP_CentroidDivide::theSOPTypeName; }

    // There are a few choices for the cookMode.
    // For SOPs with no inputs that only generate geometry use COOK_GENERATOR
    // For SOPs that modify the input, COOK_DUPLICATE or COOK_INPLACE is usually
    // the best option, with COOK_DUPLICATE creating a full copy of the input detail
    // and COOK_INPLACE working on the input detail directly.
    // The final option COOK_GENERIC allows any number of inputs, but the detail you
    // get in ::cook will be empty by default. This mode is useful for SOPs like Sweep
    // that combine two separate geometries in an interesting way.
    CookMode cookMode(const SOP_NodeParms *parms) const override { return COOK_INPLACE; }

    void cook(const CookParms &cookparms) const override;
};

// Register a verb for our SOP
static SOP_NodeVerb::Register<SOP_CentroidDivideVerb> theSOPCentroidDivideVerb;

const SOP_NodeVerb *
SOP_CentroidDivide::cookVerb() const 
{ 
    return theSOPCentroidDivideVerb.get();
}

void
SOP_CentroidDivideVerb::cook(const SOP_NodeVerb::CookParms &cookparms) const
{
    auto &&sopparms = cookparms.parms<SOP_CentroidDivideParms>();
    GU_Detail *detail = cookparms.gdh().gdpNC();

    // Get input parameters.
    UT_StringHolder groupname = sopparms.getGroup();

    // Parse our group.
    GOP_Manager gop;
    const GA_PrimitiveGroup *group = nullptr;
    if (groupname.isstring())
    {
        // NOTE: Use a detached group here.
        group = gop.parsePrimitiveGroups(
            /*pat=*/groupname,
            /*creator=*/GOP_Manager::GroupCreator(/*detail=*/detail, /*detached=*/true));
    }

    // Make a group we will use to collect all the closed polygons in our
    // group that we will divide and then delete.

    // Collect the polygons that will be removed in an offset list.
    GA_OffsetList rm_polys;

    // One triangle added per edge.
    exint num_new_prims = 0;
    for (GA_Offset prim_off : detail->getPrimitiveRange(group))
    {
        // Only handle closed polygons
        if (detail->getPrimitiveTypeId(prim_off) != GA_PRIMPOLY
            || !detail->getPrimitiveClosedFlag(prim_off))
            continue;

        // Add this prim to our list to divide and then remove.
        rm_polys.append(prim_off);
        // The polygon is closed so we have one edge per vertex.
        // And we are going to create one triangle per edge.
        num_new_prims += detail->getPrimitiveVertexCount(prim_off);
    }

    // For copying/interpolating attributes from the source geometry
    // onto the newly created geometry.
    GA_PointWrangler pt_wrangler(*detail, GA_PointWrangler::INCLUDE_P);
    GA_PrimitiveWrangler prim_wrangler(*detail);
    GA_VertexWrangler vtx_wrangler(*detail);

    // Add a block of new points to the detail. These are the
    // new points at the centroids of each polygon.
    GA_Size num_new_points = rm_polys.entries();
    GA_Offset point_block_start = detail->appendPointBlock(/*npoints=*/num_new_points);

    // Add a block of polygons each with 3 vertices.
    // This also adds a block of 3 * num_new_prims vertices.
    GA_Offset vertex_block_start;
    GA_Offset prim_block_start = detail->appendPrimitivesAndVertices(
        /*type=*/GA_PRIMPOLY,
        /*nprimitives=*/num_new_prims,
        /*nvertices_each=*/3,
        /*vertex_block_start=*/vertex_block_start,
        /*closed_flag=*/true);

    // Use these to keep track of which new point/vertex/prim we are on.
    GA_Offset new_pt = point_block_start;
    GA_Offset new_prim_vtx0 = vertex_block_start;
    GA_Offset new_prim = prim_block_start;
    for (GA_Offset source_prim : rm_polys)
    {
        int nvtx = detail->getPrimitiveVertexCount(source_prim);

        // Loop over the edges.
        for (int vi = 0; vi < nvtx; ++vi)
        {
            int vi_next = (vi + 1) % nvtx;

            GA_Offset source_vtx1 = detail->getPrimitiveVertexOffset(source_prim, vi);
            GA_Offset source_vtx2 = detail->getPrimitiveVertexOffset(source_prim, vi_next);
            GA_Offset source_pt1 = detail->vertexPoint(source_vtx1);
            GA_Offset source_pt2 = detail->vertexPoint(source_vtx2);

            // Our three vertices on the new triangle.
            // The one at the center
            GA_Offset new_vtx0 = new_prim_vtx0 + 3 * vi;
            // first on edge
            GA_Offset new_vtx1 = new_vtx0 + 1;
            // second on edge
            GA_Offset new_vtx2 = new_vtx0 + 2;

            // Wire the third vertex to the point at the center.
            detail->setVertexPoint(new_vtx0, new_pt);

            // Directly copy point wirings over from the source
            // vertices for the first two vertices on the triangle.
            detail->setVertexPoint(new_vtx1, source_pt1);
            detail->setVertexPoint(new_vtx2, source_pt2);

            // Directly copy for vertices around the source poly
            vtx_wrangler.copyAttributeValues(new_vtx1, source_vtx1);
            vtx_wrangler.copyAttributeValues(new_vtx2, source_vtx2);

            // Copy the attribute from the first vertex/point.
            // This will correctly handle the case of non-numerical
            // attributes which we just want to copy and numerical
            // attributes where the default value is not 0.

            // At the end we will scale it by 1.0/nvtx to
            // compute the average for any numerical attributes.

            // NOTE: We're going to interpolate vertex values and write to
            // new_prim_vtx0 first and then copy to all other vertices
            // at the centroid.
            if (vi)
            {
                vtx_wrangler.addAttributeValues(new_prim_vtx0, source_vtx1);
                pt_wrangler.addAttributeValues(new_pt, source_pt1);
            }
            else
            {
                vtx_wrangler.copyAttributeValues(new_prim_vtx0, source_vtx1);
                pt_wrangler.copyAttributeValues(new_pt, source_pt1);
            }

            // Copy new triangle attributes from source prim.
            prim_wrangler.copyAttributeValues(new_prim, source_prim);

            // One new prim per edge. Step to next new prim when done
            // with this one.
            ++new_prim;
        }

        // Numerical attributes got all added together so now we need to
        // scale by 1.0/nvtx to compute the average of each one.
        vtx_wrangler.scaleAttributeValues(new_prim_vtx0, 1.0/nvtx);
        pt_wrangler.scaleAttributeValues(new_pt, 1.0/nvtx);

        // We interpolated all the vertex attributes onto the first
        // one at the centroid but now we need to copy the attributes
        // from that vertex to the others at the centroid.
        // Note how vi starts at 1 to skip copying *to* new_prim_vtx0.
        for (int vi = 1; vi < nvtx; ++vi)
        {
            GA_Offset new_vtx0 = new_prim_vtx0 + 3 * vi;
            vtx_wrangler.copyAttributeValues(new_vtx0, new_prim_vtx0);
        }

        // new_prim_vtx0 is the first vertex in the block of vertices added
        // for this current source primitive. To advance to the next source
        // prim, we advance by the number of vertices added which is
        // num vertices per added prim (3) * num added prims (nvtx)
        new_prim_vtx0 += 3 * nvtx;

        // Each source prim has a single new point, step to the next point
        // when done with the primitive.
        ++new_pt;
    }

    // Destroy the existing polygons we just replaced with triangles.

    // Internally, the detail holds a map of GA_Offsets -> GA_Index.
    // As a user you only see the indices, however in C++ we access
    // elements through their offsets (which we can map to indices
    // with something like GA_Detail::primitiveIndex(offset))
    // When deleting elements, like with
    // GA_Detail::destroyPrimitiveOffsets, it will internally mark the
    // offset as unused, removing the index, but will not shift
    // around offsets for any primitive. Later, after this SOP
    // finishes cooking, something may choose to defragment the
    // index map, removing these unused offsets, but until this
    // happens, we can rely on primitive offsets staying the same.
    detail->destroyPrimitiveOffsets(GA_Range(detail->getPrimitiveMap(), rm_polys), true);

    if (cookparms.selectionEnabled())
    {
        // Since we know all offsets in
        // [prim_block_start, prim_block_start+num_new_prims-1]
        // are newly added prims, we can select these as follows.
        GA_Range prim_range(detail->getPrimitiveMap(),
                            prim_block_start,
                            prim_block_start+num_new_prims);

        // Set the cook selection as the final step after we have removed
        // the old primitives.
        cookparms.select(prim_range);
    }
}