SOP_Measure-2.0.proto.h

Go to the documentation of this file.

/* Automagically Generated by generate_proto.py
 * Do not Edit
 */
#pragma once

#include <SOP/SOP_NodeVerb.h>
#include <SOP/SOP_GraphProxy.h>

#include <OP/OP_Utils.h>
#include <PRM/PRM_Parm.h>
#include <UT/UT_IStream.h>
#include <UT/UT_NTStreamUtil.h>
#include <UT/UT_Ramp.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringStream.h>
#include <UT/UT_VectorTypes.h>
#include <SYS/SYS_Types.h>

using namespace UT::Literal;

class DEP_MicroNode;
namespace SOP_Measure_2_0Enums
{
    enum class GroupType
    {
        POINTS = 0,
        PRIMS
    };
    enum class Measure
    {
        PERIMETER = 0,
        AREA,
        VOLUME,
        CENTROID,
        CURVATURE,
        GRADIENT,
        LAPLACIAN,
        BOUNDARYINTEGRAL,
        SURFACEINTEGRAL
    };
    enum class CurvatureType
    {
        GAUSSIAN = 0,
        MEAN,
        PRINCIPAL,
        CURVEDNESS
    };
    enum class PrincipalType
    {
        MIN = 0,
        MAX
    };
    enum class PrincipalSign
    {
        SIGNED = 0,
        ABSOLUTE
    };
    enum class PrincipalReportAs
    {
        SCALAR = 0,
        DIRECTION,
        VECTOR
    };
    enum class IntegrationMode
    {
        COMPONENTWISE = 0,
        TANGENT,
        NORMAL
    };
    enum class SrcComp
    {
        X = 0,
        Y,
        Z,
        XYZ
    };
    enum class IntegrationDomain
    {
        ELEMENT = 0,
        PIECE,
        THROUGHOUT
    };
    enum class WidthScale
    {
        UNIT = 0,
        SD,
        MAD
    };
    enum class CenterType
    {
        FIXED = 0,
        MEAN,
        MEDIAN
    };
}


class SOP_API SOP_Measure_2_0Parms  : public SOP_NodeParms
{
public:
    static int version() { return 1; }

    SOP_Measure_2_0Parms()
    {
        myGroup = ""_sh;
        myGroupType = 1;
        myMeasure = 1;
        myCurvatureType = 3;
        myPrincipalType = 0;
        myPrincipalSign = 0;
        myPrincipalReportAs = 0;
        myUmbilicCutoff = 0;
        myIntegrationMode = 0;
        mySrcAttrib = "P"_sh;
        mySrcComp = 0;
        myScaleNormalize = true;
        myIntegrationDomain = 0;
        myPieceAttrib = "class"_sh;
        myUseCustomPos = false;
        myPosAttrib = "P"_sh;
        myUseRangeMin = false;
        myRangeMin = -1;
        myUseRangeMax = false;
        myRangeMax = 1;
        myUseCenterWidth = true;
        myWidth = 6;
        myWidthScale = 2;
        myCenterType = 2;
        myFixedCenter = 0;
        myColorramp = UT_SharedPtr<UT_Ramp>(0);
        myVectorScale = 1;
        myAttribName = "area"_sh;
        myUseTotalAttrib = false;
        myTotalAttribName = "totalarea"_sh;
        myUseRangeGroup = false;
        myRangeGroup = "inrange"_sh;
        myBakeIntoOutput = false;
        myUseRemapRange = false;
        myRemapRange = UT_Vector2D(0,1);

    }

    explicit SOP_Measure_2_0Parms(const SOP_Measure_2_0Parms &) = default;

    ~SOP_Measure_2_0Parms() override {}

    bool operator==(const SOP_Measure_2_0Parms &src) const
    {
        if (myGroup != src.myGroup) return false;
        if (myGroupType != src.myGroupType) return false;
        if (myMeasure != src.myMeasure) return false;
        if (myCurvatureType != src.myCurvatureType) return false;
        if (myPrincipalType != src.myPrincipalType) return false;
        if (myPrincipalSign != src.myPrincipalSign) return false;
        if (myPrincipalReportAs != src.myPrincipalReportAs) return false;
        if (myUmbilicCutoff != src.myUmbilicCutoff) return false;
        if (myIntegrationMode != src.myIntegrationMode) return false;
        if (mySrcAttrib != src.mySrcAttrib) return false;
        if (mySrcComp != src.mySrcComp) return false;
        if (myScaleNormalize != src.myScaleNormalize) return false;
        if (myIntegrationDomain != src.myIntegrationDomain) return false;
        if (myPieceAttrib != src.myPieceAttrib) return false;
        if (myUseCustomPos != src.myUseCustomPos) return false;
        if (myPosAttrib != src.myPosAttrib) return false;
        if (myUseRangeMin != src.myUseRangeMin) return false;
        if (myRangeMin != src.myRangeMin) return false;
        if (myUseRangeMax != src.myUseRangeMax) return false;
        if (myRangeMax != src.myRangeMax) return false;
        if (myUseCenterWidth != src.myUseCenterWidth) return false;
        if (myWidth != src.myWidth) return false;
        if (myWidthScale != src.myWidthScale) return false;
        if (myCenterType != src.myCenterType) return false;
        if (myFixedCenter != src.myFixedCenter) return false;
        if (myColorramp != src.myColorramp) return false;
        if (myVectorScale != src.myVectorScale) return false;
        if (myAttribName != src.myAttribName) return false;
        if (myUseTotalAttrib != src.myUseTotalAttrib) return false;
        if (myTotalAttribName != src.myTotalAttribName) return false;
        if (myUseRangeGroup != src.myUseRangeGroup) return false;
        if (myRangeGroup != src.myRangeGroup) return false;
        if (myBakeIntoOutput != src.myBakeIntoOutput) return false;
        if (myUseRemapRange != src.myUseRemapRange) return false;
        if (myRemapRange != src.myRemapRange) return false;

        return true;
    }
    bool operator!=(const SOP_Measure_2_0Parms &src) const
    {
        return !operator==(src);
    }
    using GroupType = SOP_Measure_2_0Enums::GroupType;
    using Measure = SOP_Measure_2_0Enums::Measure;
    using CurvatureType = SOP_Measure_2_0Enums::CurvatureType;
    using PrincipalType = SOP_Measure_2_0Enums::PrincipalType;
    using PrincipalSign = SOP_Measure_2_0Enums::PrincipalSign;
    using PrincipalReportAs = SOP_Measure_2_0Enums::PrincipalReportAs;
    using IntegrationMode = SOP_Measure_2_0Enums::IntegrationMode;
    using SrcComp = SOP_Measure_2_0Enums::SrcComp;
    using IntegrationDomain = SOP_Measure_2_0Enums::IntegrationDomain;
    using WidthScale = SOP_Measure_2_0Enums::WidthScale;
    using CenterType = SOP_Measure_2_0Enums::CenterType;



    void        buildFromOp(const SOP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
    {
        myGroup = ""_sh;
        if (true)
            graph->evalOpParm(myGroup, nodeidx, "group", time, 0);
        myGroupType = 1;
        if (true)
            graph->evalOpParm(myGroupType, nodeidx, "grouptype", time, 0);
        myMeasure = 1;
        if (true)
            graph->evalOpParm(myMeasure, nodeidx, "measure", time, 0);
        myCurvatureType = 3;
        if (true && ( (!(((int64(getMeasure())!=4)))) ) )
            graph->evalOpParm(myCurvatureType, nodeidx, "curvaturetype", time, 0);
        myPrincipalType = 0;
        if (true && ( (!(((int64(getMeasure())!=4))||((int64(getCurvatureType())!=2)))) ) )
            graph->evalOpParm(myPrincipalType, nodeidx, "principaltype", time, 0);
        myPrincipalSign = 0;
        if (true && ( (!(((int64(getMeasure())!=4))||((int64(getCurvatureType())!=2)))) ) )
            graph->evalOpParm(myPrincipalSign, nodeidx, "principalsign", time, 0);
        myPrincipalReportAs = 0;
        if (true && ( (!(((int64(getMeasure())!=4))||((int64(getCurvatureType())!=2)))) ) )
            graph->evalOpParm(myPrincipalReportAs, nodeidx, "principalreportas", time, 0);
        myUmbilicCutoff = 0;
        if (true && ( (!(((int64(getMeasure())!=4))||((int64(getCurvatureType())!=2))||((int64(getPrincipalReportAs())==0)))) ) )
            graph->evalOpParm(myUmbilicCutoff, nodeidx, "umbiliccutoff", time, 0);
        myIntegrationMode = 0;
        if (true && ( (!(((int64(getMeasure())!=7)&&(int64(getMeasure())!=8)))) ) )
            graph->evalOpParm(myIntegrationMode, nodeidx, "integrationmode", time, 0);
        mySrcAttrib = "P"_sh;
        if (true && ( (!(((int64(getMeasure())==4))||((int64(getMeasure())==2))||((int64(getMeasure())==0))||((int64(getMeasure())==1))||((int64(getMeasure())==3)))) ) )
            graph->evalOpParm(mySrcAttrib, nodeidx, "srcattrib", time, 0);
        mySrcComp = 0;
        if (true && ( (!(((int64(getMeasure())==4))||((int64(getMeasure())==2))||((int64(getMeasure())==0))||((int64(getMeasure())==1))||((int64(getMeasure())==3)))) ) )
            graph->evalOpParm(mySrcComp, nodeidx, "srccomp", time, 0);
        myScaleNormalize = true;
        if (true && ( (!(((int64(getMeasure())!=4)&&(int64(getMeasure())!=5)&&(int64(getMeasure())!=6)&&(int64(getMeasure())!=8))||((int64(getMeasure())==4)&&(int64(getCurvatureType())==0)))) ) )
            graph->evalOpParm(myScaleNormalize, nodeidx, "scalenormalize", time, 0);
        myIntegrationDomain = 0;
        if (true)
            graph->evalOpParm(myIntegrationDomain, nodeidx, "integrationdomain", time, 0);
        myPieceAttrib = "class"_sh;
        if (true && ( (!(((int64(getIntegrationDomain())!=1)))) ) )
            graph->evalOpParm(myPieceAttrib, nodeidx, "pieceattrib", time, 0);
        myUseCustomPos = false;
        if (true)
            graph->evalOpParm(myUseCustomPos, nodeidx, "usecustompos", time, 0);
        myPosAttrib = "P"_sh;
        if (true && ( (!(((getUseCustomPos()==0)))) ) )
            graph->evalOpParm(myPosAttrib, nodeidx, "posattrib", time, 0);
        myUseRangeMin = false;
        if (true && ( (!(((int64(getMeasure())==3))||((int64(getMeasure())==4)&&(int64(getPrincipalReportAs())==1)))) ) )
            graph->evalOpParm(myUseRangeMin, nodeidx, "userangemin", time, 0);
        myRangeMin = -1;
        if (true && ( (!(((int64(getMeasure())==3))||((int64(getMeasure())==4)&&(int64(getPrincipalReportAs())==1))||((getUseRangeMin()==0)))) ) )
            graph->evalOpParm(myRangeMin, nodeidx, "rangemin", time, 0);
        myUseRangeMax = false;
        if (true && ( (!(((int64(getMeasure())==3))||((int64(getMeasure())==4)&&(int64(getPrincipalReportAs())==1)))) ) )
            graph->evalOpParm(myUseRangeMax, nodeidx, "userangemax", time, 0);
        myRangeMax = 1;
        if (true && ( (!(((int64(getMeasure())==3))||((int64(getMeasure())==4)&&(int64(getPrincipalReportAs())==1))||((getUseRangeMax()==0)))) ) )
            graph->evalOpParm(myRangeMax, nodeidx, "rangemax", time, 0);
        myUseCenterWidth = true;
        if (true && ( (!(((int64(getMeasure())==3))||((int64(getMeasure())==4)&&(int64(getPrincipalReportAs())==1)))) ) )
            graph->evalOpParm(myUseCenterWidth, nodeidx, "usecenterwidth", time, 0);
        myWidth = 6;
        if (true && ( (!(((int64(getMeasure())==3))||((int64(getMeasure())==4)&&(int64(getPrincipalReportAs())==1))||((getUseCenterWidth()==0)))) ) )
            graph->evalOpParm(myWidth, nodeidx, "width", time, 0);
        myWidthScale = 2;
        if (true && ( (!(((int64(getMeasure())==3))||((int64(getMeasure())==4)&&(int64(getPrincipalReportAs())==1))||((getUseCenterWidth()==0)))) ) )
            graph->evalOpParm(myWidthScale, nodeidx, "widthscale", time, 0);
        myCenterType = 2;
        if (true && ( (!(((int64(getMeasure())==3))||((int64(getMeasure())==4)&&(int64(getPrincipalReportAs())==1))||((getUseCenterWidth()==0)))) ) )
            graph->evalOpParm(myCenterType, nodeidx, "centertype", time, 0);
        myFixedCenter = 0;
        if (true && ( (!(((int64(getCenterType())!=0))||((int64(getMeasure())==3))||((int64(getMeasure())==4)&&(int64(getPrincipalReportAs())==1))||((getUseCenterWidth()==0)))) ) )
            graph->evalOpParm(myFixedCenter, nodeidx, "fixedcenter", time, 0);
        myColorramp = UT_SharedPtr<UT_Ramp>(0);
        if (true && ( (!(((int64(getMeasure())==3))||((int64(getMeasure())==4)&&(int64(getPrincipalReportAs())==1)))) ) )
            graph->evalOpParm(myColorramp, nodeidx, "colorramp", time, 0);
        myVectorScale = 1;
        if (true && ( (!(((int64(getMeasure())==4)&&(int64(getPrincipalReportAs())==0))||((int64(getMeasure())==2))||((int64(getMeasure())==0))||((int64(getMeasure())==1))||((int64(getMeasure())==3))||((int64(getMeasure())==6)&&(int64(getSrcComp())!=3))||((int64(getMeasure())==8)&&(int64(getSrcComp())!=3))||((int64(getMeasure())==7)&&(int64(getSrcComp())!=3)))) ) )
            graph->evalOpParm(myVectorScale, nodeidx, "vectorscale", time, 0);
        myAttribName = "area"_sh;
        if (true)
            graph->evalOpParm(myAttribName, nodeidx, "attribname", time, 0);
        myUseTotalAttrib = false;
        if (true)
            graph->evalOpParm(myUseTotalAttrib, nodeidx, "usetotalattrib", time, 0);
        myTotalAttribName = "totalarea"_sh;
        if (true && ( (!(((getUseTotalAttrib()==0)))) ) )
            graph->evalOpParm(myTotalAttribName, nodeidx, "totalattribname", time, 0);
        myUseRangeGroup = false;
        if (true && ( (!(((int64(getMeasure())==3))||((int64(getMeasure())==4)&&(int64(getPrincipalReportAs())==1))||((getUseRangeMin()==0)&&(getUseRangeMax()==0)&&(getUseCenterWidth()==0)))) ) )
            graph->evalOpParm(myUseRangeGroup, nodeidx, "userangegroup", time, 0);
        myRangeGroup = "inrange"_sh;
        if (true && ( (!(((getUseRangeGroup()==0)))) ) )
            graph->evalOpParm(myRangeGroup, nodeidx, "rangegroup", time, 0);
        myBakeIntoOutput = false;
        if (true && ( (!(((int64(getMeasure())==3))||((int64(getMeasure())==4)&&(int64(getPrincipalReportAs())==1))||((getUseRangeMin()==0)&&(getUseRangeMax()==0)&&(getUseCenterWidth()==0)))) ) )
            graph->evalOpParm(myBakeIntoOutput, nodeidx, "bakeintooutput", time, 0);
        myUseRemapRange = false;
        if (true && ( (!(((getBakeIntoOutput()==0)))) ) )
            graph->evalOpParm(myUseRemapRange, nodeidx, "useremaprange", time, 0);
        myRemapRange = UT_Vector2D(0,1);
        if (true && ( (!(((getBakeIntoOutput()==0))||((getUseRemapRange()==0)))) ) )
            graph->evalOpParm(myRemapRange, nodeidx, "remaprange", time, 0);

    }


    void loadFromOpSubclass(const LoadParms &loadparms) override
    {
        buildFromOp(loadparms.graph(), loadparms.nodeIdx(), loadparms.context().getTime(), loadparms.depnode());
    }


    void copyFrom(const SOP_NodeParms *src) override
    {
        *this = *((const SOP_Measure_2_0Parms *)src);
    }

    template <typename T>
    void
    doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
    {
        if (idx.size() < 1)
            return;
        UT_ASSERT(idx.size() == instance.size()+1);
        if (idx.size() != instance.size()+1)
            return;
        switch (idx[0])
        {
            case 0:
                coerceValue(value, myGroup);
                break;
            case 1:
                coerceValue(value, myGroupType);
                break;
            case 2:
                coerceValue(value, myMeasure);
                break;
            case 3:
                coerceValue(value, myCurvatureType);
                break;
            case 4:
                coerceValue(value, myPrincipalType);
                break;
            case 5:
                coerceValue(value, myPrincipalSign);
                break;
            case 6:
                coerceValue(value, myPrincipalReportAs);
                break;
            case 7:
                coerceValue(value, myUmbilicCutoff);
                break;
            case 8:
                coerceValue(value, myIntegrationMode);
                break;
            case 9:
                coerceValue(value, mySrcAttrib);
                break;
            case 10:
                coerceValue(value, mySrcComp);
                break;
            case 11:
                coerceValue(value, myScaleNormalize);
                break;
            case 12:
                coerceValue(value, myIntegrationDomain);
                break;
            case 13:
                coerceValue(value, myPieceAttrib);
                break;
            case 14:
                coerceValue(value, myUseCustomPos);
                break;
            case 15:
                coerceValue(value, myPosAttrib);
                break;
            case 16:
                coerceValue(value, myUseRangeMin);
                break;
            case 17:
                coerceValue(value, myRangeMin);
                break;
            case 18:
                coerceValue(value, myUseRangeMax);
                break;
            case 19:
                coerceValue(value, myRangeMax);
                break;
            case 20:
                coerceValue(value, myUseCenterWidth);
                break;
            case 21:
                coerceValue(value, myWidth);
                break;
            case 22:
                coerceValue(value, myWidthScale);
                break;
            case 23:
                coerceValue(value, myCenterType);
                break;
            case 24:
                coerceValue(value, myFixedCenter);
                break;
            case 25:
                coerceValue(value, myColorramp);
                break;
            case 26:
                coerceValue(value, myVectorScale);
                break;
            case 27:
                coerceValue(value, myAttribName);
                break;
            case 28:
                coerceValue(value, myUseTotalAttrib);
                break;
            case 29:
                coerceValue(value, myTotalAttribName);
                break;
            case 30:
                coerceValue(value, myUseRangeGroup);
                break;
            case 31:
                coerceValue(value, myRangeGroup);
                break;
            case 32:
                coerceValue(value, myBakeIntoOutput);
                break;
            case 33:
                coerceValue(value, myUseRemapRange);
                break;
            case 34:
                coerceValue(value, myRemapRange);
                break;

        }
    }

    void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr<UT_Ramp> &value) const override
    { doGetParmValue(idx, instance, value); }
    void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
    { doGetParmValue(idx, instance, value); }

    template <typename T>
    void
    doSetParmValue(TempIndex idx, TempIndex instance, const T &value) 
    {
        if (idx.size() < 1)
            return;
        UT_ASSERT(idx.size() == instance.size()+1);
        if (idx.size() != instance.size()+1)
            return;
        switch (idx[0])
        {
            case 0:
                coerceValue(myGroup, value);
                break;
            case 1:
                coerceValue(myGroupType, value);
                break;
            case 2:
                coerceValue(myMeasure, value);
                break;
            case 3:
                coerceValue(myCurvatureType, value);
                break;
            case 4:
                coerceValue(myPrincipalType, value);
                break;
            case 5:
                coerceValue(myPrincipalSign, value);
                break;
            case 6:
                coerceValue(myPrincipalReportAs, value);
                break;
            case 7:
                coerceValue(myUmbilicCutoff, value);
                break;
            case 8:
                coerceValue(myIntegrationMode, value);
                break;
            case 9:
                coerceValue(mySrcAttrib, value);
                break;
            case 10:
                coerceValue(mySrcComp, value);
                break;
            case 11:
                coerceValue(myScaleNormalize, value);
                break;
            case 12:
                coerceValue(myIntegrationDomain, value);
                break;
            case 13:
                coerceValue(myPieceAttrib, value);
                break;
            case 14:
                coerceValue(myUseCustomPos, value);
                break;
            case 15:
                coerceValue(myPosAttrib, value);
                break;
            case 16:
                coerceValue(myUseRangeMin, value);
                break;
            case 17:
                coerceValue(myRangeMin, value);
                break;
            case 18:
                coerceValue(myUseRangeMax, value);
                break;
            case 19:
                coerceValue(myRangeMax, value);
                break;
            case 20:
                coerceValue(myUseCenterWidth, value);
                break;
            case 21:
                coerceValue(myWidth, value);
                break;
            case 22:
                coerceValue(myWidthScale, value);
                break;
            case 23:
                coerceValue(myCenterType, value);
                break;
            case 24:
                coerceValue(myFixedCenter, value);
                break;
            case 25:
                coerceValue(myColorramp, value);
                break;
            case 26:
                coerceValue(myVectorScale, value);
                break;
            case 27:
                coerceValue(myAttribName, value);
                break;
            case 28:
                coerceValue(myUseTotalAttrib, value);
                break;
            case 29:
                coerceValue(myTotalAttribName, value);
                break;
            case 30:
                coerceValue(myUseRangeGroup, value);
                break;
            case 31:
                coerceValue(myRangeGroup, value);
                break;
            case 32:
                coerceValue(myBakeIntoOutput, value);
                break;
            case 33:
                coerceValue(myUseRemapRange, value);
                break;
            case 34:
                coerceValue(myRemapRange, value);
                break;

        }
    }

    void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr<UT_Ramp> &value)  override
    { doSetParmValue(idx, instance, value); }
    void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value)  override
    { doSetParmValue(idx, instance, value); }

    exint getNestNumParms(TempIndex idx) const override
    {
        if (idx.size() == 0)
            return 35;
        switch (idx[0])
        {

        }
        // Invalid
        return 0;
    }

    const char *getNestParmName(TempIndex fieldnum) const override
    {
        if (fieldnum.size() < 1)
            return 0;
        switch (fieldnum[0])
        {
            case 0:
                return "group";
            case 1:
                return "grouptype";
            case 2:
                return "measure";
            case 3:
                return "curvaturetype";
            case 4:
                return "principaltype";
            case 5:
                return "principalsign";
            case 6:
                return "principalreportas";
            case 7:
                return "umbiliccutoff";
            case 8:
                return "integrationmode";
            case 9:
                return "srcattrib";
            case 10:
                return "srccomp";
            case 11:
                return "scalenormalize";
            case 12:
                return "integrationdomain";
            case 13:
                return "pieceattrib";
            case 14:
                return "usecustompos";
            case 15:
                return "posattrib";
            case 16:
                return "userangemin";
            case 17:
                return "rangemin";
            case 18:
                return "userangemax";
            case 19:
                return "rangemax";
            case 20:
                return "usecenterwidth";
            case 21:
                return "width";
            case 22:
                return "widthscale";
            case 23:
                return "centertype";
            case 24:
                return "fixedcenter";
            case 25:
                return "colorramp";
            case 26:
                return "vectorscale";
            case 27:
                return "attribname";
            case 28:
                return "usetotalattrib";
            case 29:
                return "totalattribname";
            case 30:
                return "userangegroup";
            case 31:
                return "rangegroup";
            case 32:
                return "bakeintooutput";
            case 33:
                return "useremaprange";
            case 34:
                return "remaprange";

        }
        return 0;
    }

    ParmType getNestParmType(TempIndex fieldnum) const override
    {
        if (fieldnum.size() < 1)
            return PARM_UNSUPPORTED;
        switch (fieldnum[0])
        {
            case 0:
                return PARM_STRING;
            case 1:
                return PARM_INTEGER;
            case 2:
                return PARM_INTEGER;
            case 3:
                return PARM_INTEGER;
            case 4:
                return PARM_INTEGER;
            case 5:
                return PARM_INTEGER;
            case 6:
                return PARM_INTEGER;
            case 7:
                return PARM_FLOAT;
            case 8:
                return PARM_INTEGER;
            case 9:
                return PARM_STRING;
            case 10:
                return PARM_INTEGER;
            case 11:
                return PARM_INTEGER;
            case 12:
                return PARM_INTEGER;
            case 13:
                return PARM_STRING;
            case 14:
                return PARM_INTEGER;
            case 15:
                return PARM_STRING;
            case 16:
                return PARM_INTEGER;
            case 17:
                return PARM_FLOAT;
            case 18:
                return PARM_INTEGER;
            case 19:
                return PARM_FLOAT;
            case 20:
                return PARM_INTEGER;
            case 21:
                return PARM_FLOAT;
            case 22:
                return PARM_INTEGER;
            case 23:
                return PARM_INTEGER;
            case 24:
                return PARM_FLOAT;
            case 25:
                return PARM_RAMP;
            case 26:
                return PARM_FLOAT;
            case 27:
                return PARM_STRING;
            case 28:
                return PARM_INTEGER;
            case 29:
                return PARM_STRING;
            case 30:
                return PARM_INTEGER;
            case 31:
                return PARM_STRING;
            case 32:
                return PARM_INTEGER;
            case 33:
                return PARM_INTEGER;
            case 34:
                return PARM_VECTOR2;

        }
        return PARM_UNSUPPORTED;
    }

    // Boiler plate to load individual types.
    static void  loadData(UT_IStream &is, int64 &v)
    { is.bread(&v, 1); }
    static void  loadData(UT_IStream &is, bool &v)
    { int64     iv; is.bread(&iv, 1); v = iv; }
    static void  loadData(UT_IStream &is, fpreal64 &v)
    { is.bread<fpreal64>(&v, 1); }
    static void  loadData(UT_IStream &is, UT_Vector2D &v)
    { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector3D &v)
    { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
      is.bread<fpreal64>(&v.z(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector4D &v)
    { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
      is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
    static void  loadData(UT_IStream &is, UT_Matrix2D &v)
    { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
    static void  loadData(UT_IStream &is, UT_Matrix3D &v)
    { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
    static void  loadData(UT_IStream &is, UT_Matrix4D &v)
    { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
    static void  loadData(UT_IStream &is, UT_Vector2I &v)
    { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector3I &v)
    { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
      is.bread<int64>(&v.z(), 1); }
    static void  loadData(UT_IStream &is, UT_Vector4I &v)
    { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
      is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
    static void  loadData(UT_IStream &is, UT_StringHolder &v)
    { is.bread(v); }
    static void  loadData(UT_IStream &is, UT_SharedPtr<UT_Ramp> &v)
    {   UT_StringHolder   rampdata;
        loadData(is, rampdata);
        if (rampdata.isstring())
        {
            v.reset(new UT_Ramp());
            UT_IStream  istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
            v->load(istr);
        }
        else v.reset();
    }
    static void  loadData(UT_IStream &is, PRM_DataItemHandle &v)
    {   UT_StringHolder   data;
        loadData(is, data);
        if (data.isstring())
        {
            // Find the data type.
            const char *colon = UT_StringWrap(data).findChar(':');
            if (colon)
            {
                int             typelen = colon - data.buffer();
                UT_WorkBuffer   type;
                type.strncpy(data.buffer(), typelen);
                UT_IStream  istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
                
                v = PRM_DataFactory::parseBinary(type.buffer(), istr);
            }
        }
        else v.reset();
    }

    static void  saveData(std::ostream &os, int64 v)
    { UTwrite(os, &v); }
    static void  saveData(std::ostream &os, bool v)
    { int64 iv = v; UTwrite(os, &iv); }
    static void  saveData(std::ostream &os, fpreal64 v)
    { UTwrite<fpreal64>(os, &v); }
    static void  saveData(std::ostream &os, UT_Vector2D v)
    { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
    static void  saveData(std::ostream &os, UT_Vector3D v)
    { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
      UTwrite<fpreal64>(os, &v.z()); }
    static void  saveData(std::ostream &os, UT_Vector4D v)
    { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
      UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
    static void  saveData(std::ostream &os, UT_Matrix2D v)
    { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) UTwrite<fpreal64>(os, &v(r, c)); }
    static void  saveData(std::ostream &os, UT_Matrix3D v)
    { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) UTwrite<fpreal64>(os, &v(r, c)); }
    static void  saveData(std::ostream &os, UT_Matrix4D v)
    { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) UTwrite<fpreal64>(os, &v(r, c)); }
    static void  saveData(std::ostream &os, UT_StringHolder s)
    { UT_StringWrap(s).saveBinary(os); }
    static void  saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
    {   UT_StringHolder         result;
        UT_OStringStream        ostr;
        if (s) s->save(ostr);
        result = ostr.str();
        saveData(os, result);
    }
    static void  saveData(std::ostream &os, PRM_DataItemHandle s)
    {   UT_StringHolder         result;
        UT_OStringStream        ostr;
        if (s) 
        {
            ostr << s->getDataTypeToken();
            ostr << ":";
            s->saveBinary(ostr);
        }
        result = ostr.str();
        saveData(os, result);
    }


    void         save(std::ostream &os) const
    {
        int32           v = version();
        UTwrite(os, &v);
        saveData(os, myGroup);
        saveData(os, myGroupType);
        saveData(os, myMeasure);
        saveData(os, myCurvatureType);
        saveData(os, myPrincipalType);
        saveData(os, myPrincipalSign);
        saveData(os, myPrincipalReportAs);
        saveData(os, myUmbilicCutoff);
        saveData(os, myIntegrationMode);
        saveData(os, mySrcAttrib);
        saveData(os, mySrcComp);
        saveData(os, myScaleNormalize);
        saveData(os, myIntegrationDomain);
        saveData(os, myPieceAttrib);
        saveData(os, myUseCustomPos);
        saveData(os, myPosAttrib);
        saveData(os, myUseRangeMin);
        saveData(os, myRangeMin);
        saveData(os, myUseRangeMax);
        saveData(os, myRangeMax);
        saveData(os, myUseCenterWidth);
        saveData(os, myWidth);
        saveData(os, myWidthScale);
        saveData(os, myCenterType);
        saveData(os, myFixedCenter);
        saveData(os, myColorramp);
        saveData(os, myVectorScale);
        saveData(os, myAttribName);
        saveData(os, myUseTotalAttrib);
        saveData(os, myTotalAttribName);
        saveData(os, myUseRangeGroup);
        saveData(os, myRangeGroup);
        saveData(os, myBakeIntoOutput);
        saveData(os, myUseRemapRange);
        saveData(os, myRemapRange);

    }

    bool         load(UT_IStream &is)
    {
        int32           v;
        is.bread(&v, 1);
        if (version() != v)
        {
            // Fail incompatible versions
            return false;
        }
        loadData(is, myGroup);
        loadData(is, myGroupType);
        loadData(is, myMeasure);
        loadData(is, myCurvatureType);
        loadData(is, myPrincipalType);
        loadData(is, myPrincipalSign);
        loadData(is, myPrincipalReportAs);
        loadData(is, myUmbilicCutoff);
        loadData(is, myIntegrationMode);
        loadData(is, mySrcAttrib);
        loadData(is, mySrcComp);
        loadData(is, myScaleNormalize);
        loadData(is, myIntegrationDomain);
        loadData(is, myPieceAttrib);
        loadData(is, myUseCustomPos);
        loadData(is, myPosAttrib);
        loadData(is, myUseRangeMin);
        loadData(is, myRangeMin);
        loadData(is, myUseRangeMax);
        loadData(is, myRangeMax);
        loadData(is, myUseCenterWidth);
        loadData(is, myWidth);
        loadData(is, myWidthScale);
        loadData(is, myCenterType);
        loadData(is, myFixedCenter);
        loadData(is, myColorramp);
        loadData(is, myVectorScale);
        loadData(is, myAttribName);
        loadData(is, myUseTotalAttrib);
        loadData(is, myTotalAttribName);
        loadData(is, myUseRangeGroup);
        loadData(is, myRangeGroup);
        loadData(is, myBakeIntoOutput);
        loadData(is, myUseRemapRange);
        loadData(is, myRemapRange);

        return true;
    }

    const UT_StringHolder & getGroup() const { return myGroup; }
    void setGroup(const UT_StringHolder & val) { myGroup = val; }
    UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGroup();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "group", cookparms.getCookTime(), 0);
        return result;
    }
    GroupType getGroupType() const { return GroupType(myGroupType); }
    void setGroupType(GroupType val) { myGroupType = int64(val); }
    GroupType opGroupType(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getGroupType();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "grouptype", cookparms.getCookTime(), 0);
        return GroupType(result);
    }
    Measure getMeasure() const { return Measure(myMeasure); }
    void setMeasure(Measure val) { myMeasure = int64(val); }
    Measure opMeasure(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getMeasure();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "measure", cookparms.getCookTime(), 0);
        return Measure(result);
    }
    CurvatureType getCurvatureType() const { return CurvatureType(myCurvatureType); }
    void setCurvatureType(CurvatureType val) { myCurvatureType = int64(val); }
    CurvatureType opCurvatureType(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getCurvatureType();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "curvaturetype", cookparms.getCookTime(), 0);
        return CurvatureType(result);
    }
    PrincipalType getPrincipalType() const { return PrincipalType(myPrincipalType); }
    void setPrincipalType(PrincipalType val) { myPrincipalType = int64(val); }
    PrincipalType opPrincipalType(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getPrincipalType();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "principaltype", cookparms.getCookTime(), 0);
        return PrincipalType(result);
    }
    PrincipalSign getPrincipalSign() const { return PrincipalSign(myPrincipalSign); }
    void setPrincipalSign(PrincipalSign val) { myPrincipalSign = int64(val); }
    PrincipalSign opPrincipalSign(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getPrincipalSign();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "principalsign", cookparms.getCookTime(), 0);
        return PrincipalSign(result);
    }
    PrincipalReportAs getPrincipalReportAs() const { return PrincipalReportAs(myPrincipalReportAs); }
    void setPrincipalReportAs(PrincipalReportAs val) { myPrincipalReportAs = int64(val); }
    PrincipalReportAs opPrincipalReportAs(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getPrincipalReportAs();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "principalreportas", cookparms.getCookTime(), 0);
        return PrincipalReportAs(result);
    }
    fpreal64 getUmbilicCutoff() const { return myUmbilicCutoff; }
    void setUmbilicCutoff(fpreal64 val) { myUmbilicCutoff = val; }
    fpreal64 opUmbilicCutoff(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUmbilicCutoff();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "umbiliccutoff", cookparms.getCookTime(), 0);
        return result;
    }
    IntegrationMode getIntegrationMode() const { return IntegrationMode(myIntegrationMode); }
    void setIntegrationMode(IntegrationMode val) { myIntegrationMode = int64(val); }
    IntegrationMode opIntegrationMode(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getIntegrationMode();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "integrationmode", cookparms.getCookTime(), 0);
        return IntegrationMode(result);
    }
    const UT_StringHolder & getSrcAttrib() const { return mySrcAttrib; }
    void setSrcAttrib(const UT_StringHolder & val) { mySrcAttrib = val; }
    UT_StringHolder opSrcAttrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSrcAttrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "srcattrib", cookparms.getCookTime(), 0);
        return result;
    }
    SrcComp getSrcComp() const { return SrcComp(mySrcComp); }
    void setSrcComp(SrcComp val) { mySrcComp = int64(val); }
    SrcComp opSrcComp(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getSrcComp();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "srccomp", cookparms.getCookTime(), 0);
        return SrcComp(result);
    }
    bool getScaleNormalize() const { return myScaleNormalize; }
    void setScaleNormalize(bool val) { myScaleNormalize = val; }
    bool opScaleNormalize(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getScaleNormalize();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "scalenormalize", cookparms.getCookTime(), 0);
        return result;
    }
    IntegrationDomain getIntegrationDomain() const { return IntegrationDomain(myIntegrationDomain); }
    void setIntegrationDomain(IntegrationDomain val) { myIntegrationDomain = int64(val); }
    IntegrationDomain opIntegrationDomain(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getIntegrationDomain();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "integrationdomain", cookparms.getCookTime(), 0);
        return IntegrationDomain(result);
    }
    const UT_StringHolder & getPieceAttrib() const { return myPieceAttrib; }
    void setPieceAttrib(const UT_StringHolder & val) { myPieceAttrib = val; }
    UT_StringHolder opPieceAttrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getPieceAttrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "pieceattrib", cookparms.getCookTime(), 0);
        return result;
    }
    bool getUseCustomPos() const { return myUseCustomPos; }
    void setUseCustomPos(bool val) { myUseCustomPos = val; }
    bool opUseCustomPos(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseCustomPos();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "usecustompos", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getPosAttrib() const { return myPosAttrib; }
    void setPosAttrib(const UT_StringHolder & val) { myPosAttrib = val; }
    UT_StringHolder opPosAttrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getPosAttrib();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "posattrib", cookparms.getCookTime(), 0);
        return result;
    }
    bool getUseRangeMin() const { return myUseRangeMin; }
    void setUseRangeMin(bool val) { myUseRangeMin = val; }
    bool opUseRangeMin(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseRangeMin();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "userangemin", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getRangeMin() const { return myRangeMin; }
    void setRangeMin(fpreal64 val) { myRangeMin = val; }
    fpreal64 opRangeMin(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getRangeMin();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "rangemin", cookparms.getCookTime(), 0);
        return result;
    }
    bool getUseRangeMax() const { return myUseRangeMax; }
    void setUseRangeMax(bool val) { myUseRangeMax = val; }
    bool opUseRangeMax(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseRangeMax();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "userangemax", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getRangeMax() const { return myRangeMax; }
    void setRangeMax(fpreal64 val) { myRangeMax = val; }
    fpreal64 opRangeMax(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getRangeMax();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "rangemax", cookparms.getCookTime(), 0);
        return result;
    }
    bool getUseCenterWidth() const { return myUseCenterWidth; }
    void setUseCenterWidth(bool val) { myUseCenterWidth = val; }
    bool opUseCenterWidth(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseCenterWidth();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "usecenterwidth", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getWidth() const { return myWidth; }
    void setWidth(fpreal64 val) { myWidth = val; }
    fpreal64 opWidth(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getWidth();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "width", cookparms.getCookTime(), 0);
        return result;
    }
    WidthScale getWidthScale() const { return WidthScale(myWidthScale); }
    void setWidthScale(WidthScale val) { myWidthScale = int64(val); }
    WidthScale opWidthScale(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getWidthScale();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "widthscale", cookparms.getCookTime(), 0);
        return WidthScale(result);
    }
    CenterType getCenterType() const { return CenterType(myCenterType); }
    void setCenterType(CenterType val) { myCenterType = int64(val); }
    CenterType opCenterType(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getCenterType();
        int64 result;
        OP_Utils::evalOpParm(result, thissop, "centertype", cookparms.getCookTime(), 0);
        return CenterType(result);
    }
    fpreal64 getFixedCenter() const { return myFixedCenter; }
    void setFixedCenter(fpreal64 val) { myFixedCenter = val; }
    fpreal64 opFixedCenter(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getFixedCenter();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "fixedcenter", cookparms.getCookTime(), 0);
        return result;
    }
    UT_SharedPtr<UT_Ramp> getColorramp() const { return myColorramp; }
    void setColorramp(UT_SharedPtr<UT_Ramp> val) { myColorramp = val; }
    UT_SharedPtr<UT_Ramp> opColorramp(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getColorramp();
        UT_SharedPtr<UT_Ramp> result;
        OP_Utils::evalOpParm(result, thissop, "colorramp", cookparms.getCookTime(), 0);
        return result;
    }
    fpreal64 getVectorScale() const { return myVectorScale; }
    void setVectorScale(fpreal64 val) { myVectorScale = val; }
    fpreal64 opVectorScale(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getVectorScale();
        fpreal64 result;
        OP_Utils::evalOpParm(result, thissop, "vectorscale", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getAttribName() const { return myAttribName; }
    void setAttribName(const UT_StringHolder & val) { myAttribName = val; }
    UT_StringHolder opAttribName(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getAttribName();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "attribname", cookparms.getCookTime(), 0);
        return result;
    }
    bool getUseTotalAttrib() const { return myUseTotalAttrib; }
    void setUseTotalAttrib(bool val) { myUseTotalAttrib = val; }
    bool opUseTotalAttrib(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseTotalAttrib();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "usetotalattrib", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getTotalAttribName() const { return myTotalAttribName; }
    void setTotalAttribName(const UT_StringHolder & val) { myTotalAttribName = val; }
    UT_StringHolder opTotalAttribName(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getTotalAttribName();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "totalattribname", cookparms.getCookTime(), 0);
        return result;
    }
    bool getUseRangeGroup() const { return myUseRangeGroup; }
    void setUseRangeGroup(bool val) { myUseRangeGroup = val; }
    bool opUseRangeGroup(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseRangeGroup();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "userangegroup", cookparms.getCookTime(), 0);
        return result;
    }
    const UT_StringHolder & getRangeGroup() const { return myRangeGroup; }
    void setRangeGroup(const UT_StringHolder & val) { myRangeGroup = val; }
    UT_StringHolder opRangeGroup(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getRangeGroup();
        UT_StringHolder result;
        OP_Utils::evalOpParm(result, thissop, "rangegroup", cookparms.getCookTime(), 0);
        return result;
    }
    bool getBakeIntoOutput() const { return myBakeIntoOutput; }
    void setBakeIntoOutput(bool val) { myBakeIntoOutput = val; }
    bool opBakeIntoOutput(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getBakeIntoOutput();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "bakeintooutput", cookparms.getCookTime(), 0);
        return result;
    }
    bool getUseRemapRange() const { return myUseRemapRange; }
    void setUseRemapRange(bool val) { myUseRemapRange = val; }
    bool opUseRemapRange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getUseRemapRange();
        bool result;
        OP_Utils::evalOpParm(result, thissop, "useremaprange", cookparms.getCookTime(), 0);
        return result;
    }
    UT_Vector2D getRemapRange() const { return myRemapRange; }
    void setRemapRange(UT_Vector2D val) { myRemapRange = val; }
    UT_Vector2D opRemapRange(const SOP_NodeVerb::CookParms &cookparms) const
    { 
        SOP_Node *thissop = cookparms.getNode();
        if (!thissop) return getRemapRange();
        UT_Vector2D result;
        OP_Utils::evalOpParm(result, thissop, "remaprange", cookparms.getCookTime(), 0);
        return result;
    }

private:
    UT_StringHolder myGroup;
    int64 myGroupType;
    int64 myMeasure;
    int64 myCurvatureType;
    int64 myPrincipalType;
    int64 myPrincipalSign;
    int64 myPrincipalReportAs;
    fpreal64 myUmbilicCutoff;
    int64 myIntegrationMode;
    UT_StringHolder mySrcAttrib;
    int64 mySrcComp;
    bool myScaleNormalize;
    int64 myIntegrationDomain;
    UT_StringHolder myPieceAttrib;
    bool myUseCustomPos;
    UT_StringHolder myPosAttrib;
    bool myUseRangeMin;
    fpreal64 myRangeMin;
    bool myUseRangeMax;
    fpreal64 myRangeMax;
    bool myUseCenterWidth;
    fpreal64 myWidth;
    int64 myWidthScale;
    int64 myCenterType;
    fpreal64 myFixedCenter;
    UT_SharedPtr<UT_Ramp> myColorramp;
    fpreal64 myVectorScale;
    UT_StringHolder myAttribName;
    bool myUseTotalAttrib;
    UT_StringHolder myTotalAttribName;
    bool myUseRangeGroup;
    UT_StringHolder myRangeGroup;
    bool myBakeIntoOutput;
    bool myUseRemapRange;
    UT_Vector2D myRemapRange;

};