SOP_Cleave.C

/*
 *
 * NAME:	The Cleave SOP version 1.0
 *
 * AUTHOR:      Stuart Ramsden, ANUSF Vizlab, Stuart.Ramsden@anu.edu.au
 *
 * COMMENTS:	This SOP Cleaves the geometry recursively into multiple pieces
 *
 *
 * Things to do in future:
 *               Oriented cleaving for Isotropy (compute OBB)

 *               Profile cleaving (cookie cutter) eg. jagged edge
 *               Tesselation cleaving (generalized bricker)
 *               Polygon amalgamation, either topology or color
 *               Eventually: 3D Solid cleaving

 Copyright (C) 2003  Stuart Ramsden

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details,
 at http://www.gnu.org/copyleft/gpl.html
*/

#include <UT/UT_DSOVersion.h>
#include <UT/UT_Math.h>
#include <UT/UT_Matrix3.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_Math.h>
#include <UT/UT_Interrupt.h>
#include <UT/UT_XformOrder.h>
#include <GU/GU_Detail.h>
#include <GU/GU_Align.h>
#include <GQ/GQ_Detail.h>
#include <GU/GU_PrimPoly.h>
#include <GEO/GEO_PrimType.h>
#include <PRM/PRM_Include.h>
#include <OP/OP_Operator.h>
#include <OP/OP_OperatorTable.h>
//#include <SOP/SOP_Guide.h>
#include <tools/tools.h>
#include "SOP_Cleave.h"
#include <iostream.h>

class OP_CleaveOperator : public OP_Operator
{
    public:
        OP_CleaveOperator();
        virtual ~OP_CleaveOperator();

        virtual void getOperatorHelp(const char *pathname, UT_String &str,int level) const;

};

OP_CleaveOperator::OP_CleaveOperator()
  : OP_Operator("cleave",
                "Cleave",
                SOP_Cleave::myConstructor,
                SOP_Cleave::myTemplateList,
                1,
                1,
                0)
{
}

OP_CleaveOperator::~OP_CleaveOperator()
{
}

void
OP_CleaveOperator::getOperatorHelp(const char *, UT_String &help, int /*level*/) const
{
    help  = "This SOP is useful for generating both regular\n";
    help  += "and randomized subdivisions of any polyconst char *, UT_String &help, int level) constgonal input\n";
    help  += "It recursively cleaves polygons\n";
    help  += "into sub-polygons.\n";
    help += "\n\n";
    help += "Parameters:\n";
    help += "   Frequency:             Number of recursive subdivisions\n";
    help += "\n";
    help += "   Initial Rotation:      Angle of first cleave\n";
    help += "   Cummulative Rotation:  Angle added to each recursive subdivision\n";
    help += "   Random Rotation:       Maximum angle perturbation added to each\n";
    help += "                          recursive subdivision\n";
    help += "\n";
    help += "   Seed:                  Seed for Randomness\n";
    help += "\n";
    help += "   Splits:                Number of polygons to cleave into at\n";
    help += "                          each subdivision step - 2 gives a Binary\n";
    help += "                          Space Partition (BSP), higher values cleave\n";
    help += "                          into N pie slices\n";
    help += "   Use Random Splits:     choose a split value randomly between\n";
    help += "                          2 and 'Splits' for each subdivision\n";
    help += "\n";
    help += "   Channel Width:         Thickness of channel to remove in subdivision\n";
    help += "   Channel Scale:         Amount to fractally decrease the channel width\n";
    help += "                          for successive subdivisions\n";
    help += "\n";
    help += "   Subdiv Threshold:      Set the area size limit of polygons, below which \n";
    help += "                          no subdivision will occur.\n";

}

void
newSopOperator(OP_OperatorTable *table)
{
     table->addOperator(new OP_CleaveOperator());
}


static PRM_Name
names[] =
{

    PRM_Name("freq",  "Frequency"),
    PRM_Name("init",  "Initial Rotation"),
    PRM_Name("delta", "Cummulative Rotation"),
    PRM_Name("rand", "Random Rotation"),
    PRM_Name("seed", "Seed"),

    PRM_Name("splits", "Splits"),
    PRM_Name("randsplits",  "Use Random Splits"),

    PRM_Name("dist",	"Channel Width"),
    PRM_Name("dist_scale",	"Channel Scale"),

    PRM_Name("subdiv_thresh",	"Subdiv threshold"),


};

PRM_Template
SOP_Cleave::myTemplateList[] =
{
    PRM_Template(PRM_STRING,    1, &PRMgroupName, 0, &SOP_Node::primGroupMenu),
    PRM_Template(PRM_INT_J,     1, &names[0], PRMtwoDefaults, 0, &PRMfrequency10Range),
    PRM_Template(PRM_ANGLE_J,   1, &names[1], 0, 0, &PRMangleRange),
    PRM_Template(PRM_ANGLE_J,   1, &names[2], 0, 0, &PRMangleRange),
    PRM_Template(PRM_ANGLE_J,   1, &names[3], 0, 0, &PRMangleRange),
    PRM_Template(PRM_INT_J,     1, &names[4], 0, 0, &PRMdivisionRange),
    PRM_Template(PRM_INT_J,	1, &names[5], PRMthreeDefaults, 0, &PRMorderRange),
    PRM_Template(PRM_TOGGLE,    1, &names[6]),
    PRM_Template(PRM_FLT_J,	1, &names[7], PRMzeroDefaults, 0, &PRMtoleranceRange),
    PRM_Template(PRM_FLT_J,	1, &names[8], PRMoneDefaults,  0, &PRMtoleranceRange),
    PRM_Template(PRM_FLT_J,	1, &names[9], PRMzeroDefaults, 0, &PRMtoleranceRange),
    PRM_Template(),
};


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

SOP_Cleave::SOP_Cleave(OP_Network *net, const char *name, OP_Operator *op)
  : SOP_Node(net, name, op)
{
}

SOP_Cleave::~SOP_Cleave()
{
}

OP_ERROR
SOP_Cleave::cookMySop(OP_Context &context)
{

    const GA_PrimitiveGroup  *polyGroup;

    GEO_Primitive     	*prim;
    GQ_Detail           *gqd;
    int                  i,j,k;
    UT_Vector4           np,p;

    // Before we do anything, we must lock our inputs.  Before returning,
    //	we have to make sure that the inputs get unlocked.
    if (lockInputs(context) >= UT_ERROR_ABORT) return error();

    float now = context.getTime();
    duplicateSource(0, context, 0, 1);

    // Here we determine which groups we have to work on.  We only
    //	handle poly groups.

    UT_String groups;
    getGroups(groups);

    if (groups.isstring()) polyGroup = parsePrimitiveGroups(groups);
    else                   polyGroup = 0;

    if (error() >= UT_ERROR_ABORT) {
        unlockInputs();
        return error();
    }

    UT_Interrupt* boss = UTgetInterrupt();

    // Start the interrupt server
    boss->opStart("Cleaving Polys");


    // separate out all polys to be cleaved
    GA_PrimitiveGroup* cleave_group = gdp->newPrimitiveGroup("cleave",1);
    GA_PrimitiveGroup* not_cleave_group = gdp->newPrimitiveGroup("not_cleave",1);

    if (polyGroup) {

        GA_FOR_ALL_PRIMITIVES(gdp,prim)
        {

            if ( (prim->getTypeId()==GEO_PRIMPOLY) && (polyGroup->contains(prim)!=0))
                cleave_group->add(prim);
            else
                not_cleave_group->add(prim);
        }

    } else {

        GA_FOR_ALL_PRIMITIVES(gdp,prim)
        {
            if (prim->getTypeId()==GEO_PRIMPOLY)
                cleave_group->add(prim);
            else
                not_cleave_group->add(prim);
        }
    }

    GU_Detail* scratch_gdp = new GU_Detail();
    scratch_gdp->merge(*gdp,cleave_group);

    GU_Detail* untouched_gdp = new GU_Detail();
    untouched_gdp->merge(*gdp,not_cleave_group);

    gdp->clearAndDestroy();
    gdp->merge(*scratch_gdp);
    delete scratch_gdp;

    // create rest pos attribute
    float zeros[3] = {1,1,1};

	GA_RWAttributeRef cleave_rest_pos = gdp->addFloatTuple(GA_ATTRIB_POINT, "CleaveRestPos", 3, GA_Defaults(3, GA_STORE_REAL32, 0.0, 0.0, 0.0));

    // Pointer to the color data
    float* rpos = 0;
    GEO_Point* ppt = 0;

    UT_Vector4 pos;
    UT_Vector3 Anorm;
    UT_Vector3 Bnorm;

    // disassociate the polygons
    gdp->uniquePoints();

    // assign rest pos attribute

    for (i = 0; i < gdp->points().entries(); i++) {



        ppt = gdp->points()(i);

        pos = ppt->getPos();

		UT_Vector3 nrestPos(pos.x(), pos.y(), pos.z());
		ppt->setValue(cleave_rest_pos,UT_Vector3(pos.x(), pos.y(), pos.z()));


    }


    float dist = DIST(now)/5.;
    float dscale = DSCALE(now);
    float sthresh = STHRESH(now)/10.;
    float deg = ANG(now);
    int splits = SPLITS(now);

    int curr_splits = splits;

    // create align geometry
    UT_Matrix4 mat;
    GU_AlignParms gap;
    gap.bias = 1;
    mat.identity();
    gap.postxform = mat;

    GU_Detail* align_gdp = new GU_Detail();
    gap.auxprim = align_gdp->polyGrid(2,2);

    // and align them to the XY plane
    gdp->align(gap);

    UT_XformOrder order("xyz");

    unsigned int seed = SEED(now);

    UT_Matrix4D mat4;

    float rval;

    float area = 0;
    GEO_Point* apt = 0;
    GEO_Point* bpt = 0;
    GEO_Point* cpt = 0;

    UT_Vector4 base;
    UT_Vector4 rel;

    float delta_deg;
    float arad;
    float brad;

    GU_Detail* current_gdp = 0;
    GU_Detail* orig_gdp = 0;

    for(j=0;j<FREQ(now);j++) {

        if (boss->opInterrupt()) break;

        if (RSPLITS()) {
            curr_splits = int(floor(2.5+float(splits-2)*UTfastRandom(seed)));
        }

        current_gdp = new GU_Detail;

        // loop with area calculation
        GA_FOR_ALL_PRIMITIVES(gdp,prim)
        {

            // Area computation
            area = 0.0;
            apt = prim->getVertex(0).getPt();

            for (i = prim->getVertexCount()-1; i >= 1; i--) {

                bpt = prim->getVertex(i).getPt();
                cpt = prim->getVertex(i-1).getPt();

                base = bpt->getPos() - apt->getPos();
                rel = cpt->getPos() - apt->getPos();
                area += (rel[0]*base[1] - rel[1]*base[0])/2.;

            }

            if(area <= sthresh) {

                current_gdp->merge(*prim);
                continue;

            }

            pos = prim->baryCenter();
            mat4.identity();

            rval = 2*UTfastRandomZero(seed);

            if (j!=0) mat4.rotate(0,0,UTdegToRad(DANG(now)+rval*RANG(now)),order);
            else      mat4.rotate(0,0,UTdegToRad(rval*RANG(now)),order);

             // center and rotate polys
            for (i = prim->getVertexCount()-1; i >= 0; i--) {

                ppt = prim->getVertex(i).getPt();
                ppt->setPos(ppt->getPos() - pos);
                UT_Vector4D cPos = ppt->getPos();
				cPos.multiply3(mat4);
				ppt->setPos(cPos);


            }

            scratch_gdp = new GU_Detail();
            scratch_gdp->merge(*prim);
            scratch_gdp->uniquePoints();

            if ((curr_splits%2==0)&&(dist==0)) {

                // fast cleaving via creasing - only even cleaves, without channels
                delta_deg = 360./curr_splits;
                gqd = new GQ_Detail(scratch_gdp);

                for(k=0;k<curr_splits/2;k++) {

                    arad = UTdegToRad(deg+k*delta_deg);
                    Anorm.assign(cos(arad),sin(arad),0);
                    gqd->crease(Anorm, 0, 0, 0);

                }

                delete gqd;

                scratch_gdp->destroyUnusedPoints();
                scratch_gdp->uniquePoints();

                // accumulate result
                current_gdp->merge(*scratch_gdp);
                current_gdp->uniquePoints();

            } else {

                orig_gdp = new GU_Detail;
                orig_gdp->merge(*scratch_gdp);

                delta_deg = 360./curr_splits;
                for(k=0;k<curr_splits;k++) {

                    arad = UTdegToRad(deg+k*delta_deg);
                    Anorm.assign(cos(arad),sin(arad),0);

                    gqd = new GQ_Detail(scratch_gdp);
                    gqd->clip(Anorm, -dist, 0);
                    delete gqd;

                    // second clip - necessary for any splits > 2
                    if (splits>2) {

                        brad = UTdegToRad(deg+(k+1)*delta_deg);
                        Bnorm.assign(-cos(brad),-sin(brad),0);
                        gqd = new GQ_Detail(scratch_gdp);
                        gqd->clip(Bnorm, -dist, 0);
                        delete gqd;
                    }

                    // accumulate result
                    current_gdp->merge(*scratch_gdp);
                    scratch_gdp->clearAndDestroy();
                    if(k != (curr_splits-1)) scratch_gdp->merge(*orig_gdp);

                }

                delete orig_gdp;

            }

            delete scratch_gdp;

        }

        gdp->clearAndDestroy();
        gdp->merge(*current_gdp);

        dist *= dscale;

    }

    delete align_gdp;
    // restore rest positions
    for (i = 0; i < gdp->points().entries(); i++) {

        ppt = gdp->points()(i);

        // Use the index that we were returned in the example above
        pos = ppt->getPos();
		UT_Vector3 vrpos = ppt->getValue<UT_Vector3>(cleave_rest_pos);
		ppt->setPos(vrpos.x(),vrpos.y(),vrpos.z());

    }

    // delete rest pos
    gdp->destroyPointAttrib("CleaveRestPos");

    // restore non-poly primitives and untouched polys
    gdp->merge(*untouched_gdp);
    delete untouched_gdp;

    // Tell the interrupt server that we've completed
    boss->opEnd();

    unlockInputs();
    return error();

}


const char *
SOP_Cleave::inputLabel(unsigned) const
{
    return "Geometry to Cleave";
}