SOP_SweepHDK.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.
 *
 *----------------------------------------------------------------------------
 * This SOP creates grid surfaces around curves in the first input, optionally
 * using cross sections from the second input.  If only the second input is
 * connected, it will surface the cross sections where they're already located.
 */

// A .proto.h file is an automatically generated header file based on theDsFile,
// below, to provide SOP_SweepHDKParms, an easy way to access parameter
// values from SOP_SweepHDKVerb::cook with the correct type, and
// SOP_SweepHDKEnums, a namespace containing enum types for any ordinal
// menu parameters.
#include "SOP_SweepHDK.proto.h"

#include "GU_Grid.h"
#include "GU_GridImpl.h"

#include "../SOP_OrientAlongCurve/GU_CurveFrame.h"
#include "../SOP_CopyToPoints/GEO_BuildPrimitives.h"
#include "../SOP_CopyToPoints/GU_Copy2.h"

#include <SOP/SOP_Node.h>
#include <SOP/SOP_NodeVerb.h>
#include <GU/GU_Detail.h>
#include <GOP/GOP_Manager.h>
#include <GEO/GEO_Curve.h>
#include <GEO/GEO_Hull.h>
#include <GEO/GEO_ParallelWiringUtil.h>
#include <GEO/GEO_PrimPoly.h>
#include <GEO/GEO_PrimPolySoup.h>
#include <GEO/GEO_TPSurf.h>
#include <GA/GA_AttributeFilter.h>
#include <GA/GA_AttributeInstanceMatrix.h>
#include <GA/GA_BezBasis.h>
#include <GA/GA_DataBitArray.h>
#include <GA/GA_Handle.h>
#include <GA/GA_Iterator.h>
#include <GA/GA_Names.h>
#include <GA/GA_NUBBasis.h>
#include <GA/GA_OffsetList.h>
#include <GA/GA_PolyCounts.h>
#include <GA/GA_SplittableRange.h>
#include <GA/GA_Types.h>
#include <OP/OP_AutoLockInputs.h>
#include <OP/OP_Operator.h>
#include <OP/OP_OperatorTable.h>
#include <PRM/PRM_TemplateBuilder.h>
#include <UT/UT_BitArray.h>
#include <UT/UT_BoundingCircle.h>
#include <UT/UT_DSOVersion.h>
#include <UT/UT_Interrupt.h>
#include <UT/UT_PageArray.h>
#include <UT/UT_PageArrayImpl.h>
#include <UT/UT_ParallelUtil.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_Vector3.h>
#include <SYS/SYS_Math.h>

#include <algorithm> // For std::make_heap, push_heap, pop_heap

namespace HDK_Sample {

//******************************************************************************
//*                 Setup                                                      *
//******************************************************************************

constexpr static int theUComponent = 0;
constexpr static int theVComponent = 1;

constexpr static int theCurveInput = 0;
constexpr static int theCrossSectionInput = 1;

namespace {
struct CrossSectionAttribMatchData
{
    /// Handle for reading int64 attribute on curve input.
    /// If valid, it could be a point, vertex, primitive, or detail attribute.
    /// If invalid, myCurveStrAttrib might be valid.
    GA_ROHandleID myCurveIntAttrib;

    /// Handle for reading string attribute on curve input.
    /// If valid, it could be a point, vertex, primitive, or detail attribute.
    /// This can only be valid if myCurveIntAttrib is invalid.
    GA_ROHandleS myCurveStrAttrib;

    /// Map from integer to primitive offset in the cross section input.
    /// This won't be used at the same time as myStrToPrimOff.
    /// NOTE: UT::ArrayMap<exint,...> doesn't support 0x8000000000000000LL
    ///       as a key, which is probably safe to exclude.
    ///       If you need a map without any excluded values, UT_Map works.
    UT::ArrayMap<exint, GA_Offset> myIntToPrimOff;

    /// Map from string to primitive offset in the cross section input.
    /// This won't be used at the same time as myIntToPrimOff.
    /// NOTE: UT_ArrayStringMap doesn't support "" as a key, so any
    ///       primitives with name "" won't be matched, which is probably
    ///       what'd be expected anyway.
    ///       If you need a map without any excluded values, UT_Map works.
    UT_ArrayStringMap<GA_Offset> myStrToPrimOff;

    /// This is just a cache of the owner of myCurveIntAttrib or
    /// myCurveStrAttrib, whichever is valid, or GA_ATTRIB_INVALID if
    /// neither is valid.
    GA_AttributeOwner myCurveAttribOwner = GA_ATTRIB_INVALID;

    /// If myCurveIntAttrib is valid and the cross section geometry doesn't
    /// have a matching attribute, it will use the primitive index, instead
    /// of a map.
    bool myIsUsingMap = false;
};


struct sop_SweepGrid
{
    sop_SweepGrid()
        : mySingleCrossSection(true)
    {}
    ~sop_SweepGrid()
    {
        if (!mySingleCrossSection)
            delete myCrossSectionPrimOffs;
    }

    // Copy constructor, for handling myCrossSectionPrimOffs union.
    sop_SweepGrid(const sop_SweepGrid &that)
        : myStartPtOff(that.myStartPtOff)
        , myStartPrimOff(that.myStartPrimOff)
        , myStartVtxOff(that.myStartVtxOff)
        , myCurveNEdges(that.myCurveNEdges)
        , myCrossSectionNEdges(that.myCrossSectionNEdges)
        , myCurvePrimOff(that.myCurvePrimOff)
        , myCurveClosed(that.myCurveClosed)
        , myCurveUnrolled(that.myCurveUnrolled)
        , myCrossSectionClosed(that.myCrossSectionClosed)
        , myCrossSectionUnrolled(that.myCrossSectionUnrolled)
        , mySingleCrossSection(that.mySingleCrossSection)
        , myAllEqualNEdges(that.myAllEqualNEdges)
        , myUEndPoles(that.myUEndPoles)
        , myVEndPoles(that.myVEndPoles)
        , myHasPolygonCaps(that.myHasPolygonCaps)
        , myPrimitiveType(that.myPrimitiveType)
        , myBasisOrderCurve(that.myBasisOrderCurve)
        , myBasisOrderCrossSection(that.myBasisOrderCrossSection)
    {
        if (that.mySingleCrossSection)
            myCrossSectionPrimOff = that.myCrossSectionPrimOff;
        else
            myCrossSectionPrimOffs = new GA_OffsetList(*that.myCrossSectionPrimOffs);
    }

    // Move constructor, for handling myCrossSectionPrimOffs union.
    sop_SweepGrid(sop_SweepGrid &&that)
        : myStartPtOff(that.myStartPtOff)
        , myStartPrimOff(that.myStartPrimOff)
        , myStartVtxOff(that.myStartVtxOff)
        , myCurveNEdges(that.myCurveNEdges)
        , myCrossSectionNEdges(that.myCrossSectionNEdges)
        , myCurvePrimOff(that.myCurvePrimOff)
        , myCurveClosed(that.myCurveClosed)
        , myCurveUnrolled(that.myCurveUnrolled)
        , myCrossSectionClosed(that.myCrossSectionClosed)
        , myCrossSectionUnrolled(that.myCrossSectionUnrolled)
        , mySingleCrossSection(that.mySingleCrossSection)
        , myAllEqualNEdges(that.myAllEqualNEdges)
        , myUEndPoles(that.myUEndPoles)
        , myVEndPoles(that.myVEndPoles)
        , myHasPolygonCaps(that.myHasPolygonCaps)
        , myPrimitiveType(that.myPrimitiveType)
        , myBasisOrderCurve(that.myBasisOrderCurve)
        , myBasisOrderCrossSection(that.myBasisOrderCrossSection)
    {
        if (that.mySingleCrossSection)
            myCrossSectionPrimOff = that.myCrossSectionPrimOff;
        else
        {
            myCrossSectionPrimOffs = that.myCrossSectionPrimOffs;
            that.mySingleCrossSection = true;
        }
    }

    // Copy assignment operator, for handling myCrossSectionPrimOffs union.
    sop_SweepGrid &operator=(const sop_SweepGrid &that)
    {
        if (this == &that)
            return *this;

        myStartPtOff = that.myStartPtOff;
        myStartPrimOff = that.myStartPrimOff;
        myStartVtxOff = that.myStartVtxOff;
        myCurveNEdges = that.myCurveNEdges;
        myCrossSectionNEdges = that.myCrossSectionNEdges;
        myCurvePrimOff = that.myCurvePrimOff;
        if (!mySingleCrossSection)
            delete myCrossSectionPrimOffs;
        if (that.mySingleCrossSection)
            myCrossSectionPrimOff = that.myCrossSectionPrimOff;
        else
            myCrossSectionPrimOffs = new GA_OffsetList(*that.myCrossSectionPrimOffs);
        myCurveClosed = that.myCurveClosed;
        myCurveUnrolled = that.myCurveUnrolled;
        myCrossSectionClosed = that.myCrossSectionClosed;
        myCrossSectionUnrolled = that.myCrossSectionUnrolled;
        mySingleCrossSection = that.mySingleCrossSection;
        myAllEqualNEdges = that.myAllEqualNEdges;
        myUEndPoles = that.myUEndPoles;
        myVEndPoles = that.myVEndPoles;
        myHasPolygonCaps = that.myHasPolygonCaps;
        myPrimitiveType = that.myPrimitiveType;
        myBasisOrderCurve = that.myBasisOrderCurve;
        myBasisOrderCrossSection = that.myBasisOrderCrossSection;
        return *this;
    }

    // Move assignment operator, for handling myCrossSectionPrimOffs union.
    sop_SweepGrid &operator=(sop_SweepGrid &&that)
    {
        if (this == &that)
            return *this;

        myStartPtOff = that.myStartPtOff;
        myStartPrimOff = that.myStartPrimOff;
        myStartVtxOff = that.myStartVtxOff;
        myCurveNEdges = that.myCurveNEdges;
        myCrossSectionNEdges = that.myCrossSectionNEdges;
        myCurvePrimOff = that.myCurvePrimOff;
        if (!mySingleCrossSection)
            delete myCrossSectionPrimOffs;
        if (that.mySingleCrossSection)
            myCrossSectionPrimOff = that.myCrossSectionPrimOff;
        else
        {
            myCrossSectionPrimOffs = that.myCrossSectionPrimOffs;
            that.mySingleCrossSection = true;
        }
        myCurveClosed = that.myCurveClosed;
        myCurveUnrolled = that.myCurveUnrolled;
        myCrossSectionClosed = that.myCrossSectionClosed;
        myCrossSectionUnrolled = that.myCrossSectionUnrolled;
        mySingleCrossSection = that.mySingleCrossSection;
        myAllEqualNEdges = that.myAllEqualNEdges;
        myUEndPoles = that.myUEndPoles;
        myVEndPoles = that.myVEndPoles;
        myHasPolygonCaps = that.myHasPolygonCaps;
        myPrimitiveType = that.myPrimitiveType;
        myBasisOrderCurve = that.myBasisOrderCurve;
        myBasisOrderCrossSection = that.myBasisOrderCrossSection;
        return *this;
    }

    GA_Offset myStartPtOff;
    GA_Offset myStartPrimOff;
    GA_Offset myStartVtxOff;
    exint myCurveNEdges;
    exint myCrossSectionNEdges;
    GA_Offset myCurvePrimOff;
    union {
        /// NOTE: This is exint instead of GA_Offset just because unions need
        ///       all POD types, and GA_Offset isn't POD in strict types builds.
        exint myCrossSectionPrimOff;
        GA_OffsetList *myCrossSectionPrimOffs;
    };
    bool myCurveClosed:1;
    bool myCurveUnrolled:1;
    bool myCrossSectionClosed:1;
    bool myCrossSectionUnrolled:1;
    bool mySingleCrossSection:1;
    bool myAllEqualNEdges:1;
    bool myUEndPoles:1;
    bool myVEndPoles:1;
    bool myHasPolygonCaps:1;
    using PrimitiveType = GU_GridT<GA_Offset>::PrimitiveType;
    PrimitiveType myPrimitiveType;
    unsigned char myBasisOrderCurve:4;
    unsigned char myBasisOrderCrossSection:4;
};
}

class SOP_SweepHDKCache : public SOP_NodeCache, public GU_CopyToPointsCache
{
public:
    SOP_SweepHDKCache() : SOP_NodeCache(), GU_CopyToPointsCache(),
        myPrevCurvePrimListDataID(-1),
        myPrevCurveTopologyDataID(-1),
        myPrevOutputDetailID(-1),
        myPrevCopyOrder(SOP_SweepHDKEnums::CopyOrder::CYCLEVTX),
        myPrevSurfaceType(SOP_SweepHDKEnums::SurfaceType::POINTS),
        myPrevPrimType(SOP_SweepHDKEnums::PrimType::AUTO),
        myPrevSurfaceShape(SOP_SweepHDKEnums::SurfaceShape::INPUT),
        myPrevCols(-1),
        myPrevEndCapType(SOP_SweepHDKEnums::EndCapType::NONE),
        myPrevEndCapDivs(-1),
        myPrevCrossSectionPrimListDataID(-1),
        myPrevCrossSectionTopologyDataID(-1),
        myPrevUnrollClosedRowCol(false),
        myPrevCloseIfNoCurveInput(false),
        myPrevTriangularPoles(false),
        myPrevSwapRowCol(false),
        myPrevCrossSectCurveAttribDataId(-1),
        myPrevCrossSectPrimAttribDataId(-1)
    {}
    ~SOP_SweepHDKCache() override {}

    int64 myPrevOutputDetailID;
    int64 myPrevCurvePrimListDataID;
    int64 myPrevCurveTopologyDataID;
    GA_OffsetList myPrevCurveGroup;
    int64 myPrevCrossSectionPrimListDataID;
    int64 myPrevCrossSectionTopologyDataID;
    GA_OffsetList myPrevCrossSectionGroup;

    SOP_SweepHDKEnums::CopyOrder myPrevCopyOrder;
    SOP_SweepHDKEnums::SurfaceType myPrevSurfaceType;
    SOP_SweepHDKEnums::PrimType myPrevPrimType;
    /// We'll use NONE to represent using the cross section input.
    SOP_SweepHDKEnums::SurfaceShape myPrevSurfaceShape;
    int64 myPrevCols;
    SOP_SweepHDKEnums::EndCapType myPrevEndCapType;
    int64 myPrevEndCapDivs;
    bool myPrevUnrollClosedRowCol;
    bool myPrevCloseIfNoCurveInput;
    bool myPrevTriangularPoles;
    bool myPrevSwapRowCol;
    int64 myPrevCrossSectCurveAttribDataId;
    int64 myPrevCrossSectPrimAttribDataId;
    CrossSectionAttribMatchData myCrossSectionAttribMatchData;

    exint myNumGrids;
    UT_Array<sop_SweepGrid> myGrids;

    // These are indices into the transform arrays for the start of each grid.
    UT_UniquePtr<exint[]> myGridTransformStarts;
};

struct sop_SweepGridTransformWrapper
{
    sop_SweepGridTransformWrapper() {}

    void init(const SOP_SweepHDKCache &cache, exint gridi)
    {
        exint offset = cache.myGridTransformStarts[gridi];
        myTranslated = cache.myTransformTranslates3D ? (cache.myTransformTranslates3D.get() + offset) : nullptr;
        myMatrix3d = cache.myTransformMatrices3D ? (cache.myTransformMatrices3D.get() + offset) : nullptr;
        myInverse3d = cache.myTransformInverse3D ? (cache.myTransformInverse3D.get() + offset) : nullptr;
        myQuaterniond = cache.myTransformQuaternionsD ? (cache.myTransformQuaternionsD.get() + offset) : nullptr;
        myTranslatef = cache.myTransformTranslates3F ? (cache.myTransformTranslates3F.get() + offset) : nullptr;
        myMatrix3f = cache.myTransformMatrices3F ? (cache.myTransformMatrices3F.get() + offset) : nullptr;
        myInverse3f = cache.myTransformInverse3F ? (cache.myTransformInverse3F.get() + offset) : nullptr;
        myQuaternionf = cache.myTransformQuaternionsF ? (cache.myTransformQuaternionsF.get() + offset) : nullptr;
    }

    template<typename T>
    const UT_Vector3T<T> *getTranslates() const
    {
        SYS_STATIC_ASSERT((SYSisSame<T,double>()) || (SYSisSame<T,float>()));

        // NOTE: The reinterpret_cast's are just needed to get this to compile;
        //       the returned value should not change type.
        return SYSisSame<T,double>()
            ? reinterpret_cast<const UT_Vector3T<T> *>(myTranslated)
            : reinterpret_cast<const UT_Vector3T<T> *>(myTranslatef);
    }

    template<typename T>
    const UT_Matrix3T<T> *getInverse3s() const
    {
        SYS_STATIC_ASSERT((SYSisSame<T,double>()) || (SYSisSame<T,float>()));

        // NOTE: The reinterpret_cast's are just needed to get this to compile;
        //       the returned value should not change type.
        return SYSisSame<T,double>()
            ? reinterpret_cast<const UT_Matrix3T<T> *>(myInverse3d)
            : reinterpret_cast<const UT_Matrix3T<T> *>(myInverse3f);
    }

    template<typename T>
    const UT_Matrix3T<T> *getMatrix3s() const
    {
        SYS_STATIC_ASSERT((SYSisSame<T,double>()) || (SYSisSame<T,float>()));

        // NOTE: The reinterpret_cast's are just needed to get this to compile;
        //       the returned value should not change type.
        return SYSisSame<T,double>()
            ? reinterpret_cast<const UT_Matrix3T<T> *>(myMatrix3d)
            : reinterpret_cast<const UT_Matrix3T<T> *>(myMatrix3f);
    }

    template<typename T>
    const UT_QuaternionT<T> *getQuaternions() const
    {
        SYS_STATIC_ASSERT((SYSisSame<T,double>()) || (SYSisSame<T,float>()));

        // NOTE: The reinterpret_cast's are just needed to get this to compile;
        //       the returned value should not change type.
        return SYSisSame<T,double>()
            ? reinterpret_cast<const UT_QuaternionT<T> *>(myQuaterniond)
            : reinterpret_cast<const UT_QuaternionT<T> *>(myQuaternionf);
    }

    UT_Vector3D *myTranslated;
    UT_Matrix3D *myMatrix3d;
    UT_Matrix3D *myInverse3d;
    UT_QuaternionD *myQuaterniond;
    UT_Vector3F *myTranslatef;
    UT_Matrix3F *myMatrix3f;
    UT_Matrix3F *myInverse3f;
    UT_QuaternionF *myQuaternionf;
};


class SOP_SweepHDKVerb : public SOP_NodeVerb
{
public:
    SOP_NodeParms *allocParms() const override { return new SOP_SweepHDKParms(); }
    SOP_NodeCache *allocCache() const override { return new SOP_SweepHDKCache(); }
    UT_StringHolder name() const override { return theSOPTypeName; }

    CookMode cookMode(const SOP_NodeParms *parms) const override { return COOK_GENERIC; }

    void cook(const CookParms &cookparms) const override;

    /// This is the internal name of the SOP type.
    /// It isn't allowed to be the same as any other SOP's type name.
    static const UT_StringHolder theSOPTypeName;

    /// This static data member automatically registers
    /// this verb class at library load time.
    static const SOP_NodeVerb::Register<SOP_SweepHDKVerb> theVerb;

    /// This is the parameter interface string, below.
    static const char *const theDsFile;
};

// The static member variable definitions have to be outside the class definition.
// The declarations are inside the class.
const UT_StringHolder SOP_SweepHDKVerb::theSOPTypeName("hdk_sweep"_sh);
const SOP_NodeVerb::Register<SOP_SweepHDKVerb> SOP_SweepHDKVerb::theVerb;

/// This is the SOP class definition.
class SOP_SweepHDK : public SOP_Node
{
public:
    static PRM_Template *buildTemplates();

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

protected:
    const SOP_NodeVerb *cookVerb() const override;

    SOP_SweepHDK(OP_Network *net, const char *name, OP_Operator *op)
        : SOP_Node(net, name, op)
    {
        // All verb SOPs must manage data IDs, to track what's changed
        // from cook to cook.
        mySopFlags.setManagesDataIDs(true);
    }

    ~SOP_SweepHDK() override {}

    OP_ERROR cookInputGroups(OP_Context &context, int alone) override;

    /// Since this SOP implements a verb, cookMySop just delegates to the verb.
    OP_ERROR cookMySop(OP_Context &context) override
    {
        return cookMyselfAsVerb(context);
    }

    /// These are the labels that appear when hovering over the inputs.
    const char *inputLabel(unsigned idx) const override
    {
        switch (idx)
        {
            case 0:     return "Backbone Curves";
            case 1:     return "Cross Section(s)";
            default:    return "Invalid Source";
        }
    }

    /// This just indicates whether an input wire gets drawn with a dotted line
    /// in the network editor.  If something is usually copied directly
    /// into the output, a solid line (false) is used, but this SOP very often
    /// doesn't do that for either input.
    int isRefInput(unsigned i) const override
    {
        // First or second input both use dotted lines
        return (i == 0 || i == 1);
    }
};

PRM_Template *SOP_SweepHDK::buildTemplates()
{
    static PRM_TemplateBuilder templ("SOP_SweepHDK.C"_sh, SOP_SweepHDKVerb::theDsFile);
    if (templ.justBuilt())
    {
        templ.setChoiceListPtr("curvegroup", &SOP_Node::primGroupMenu);
        // FIXME: This needs to select primitive groups from input 1, not input 0!!!
        templ.setChoiceListPtr("crosssectiongroup", &SOP_Node::primGroupMenu);
    }
    return templ.templates();
}

const SOP_NodeVerb *SOP_SweepHDK::cookVerb() const
{
    return SOP_SweepHDKVerb::theVerb.get();
}

} // End of HDK_Sample namespace

/// newSopOperator is the hook that Houdini grabs from this dll
/// and invokes to register the SOP.  In this case, we add ourselves
/// to the specified operator table.
void newSopOperator(OP_OperatorTable *table)
{
    // NOTE: Even though this SOP requires at least one of the two
    //       inputs to be connected, if we specified the minimum number
    //       of sources as 1, the node would error out when providing only
    //       the second (cross section) input, which isn't what we want,
    //       so instead, we specify 0 as the minimum number of sources,
    //       and explicitly error in the cook function if neither input is
    //       present.
    table->addOperator(new OP_Operator(
        HDK_Sample::SOP_SweepHDKVerb::theSOPTypeName,   // Internal name
        "HDK Sweep",                                    // UI name
        HDK_Sample::SOP_SweepHDK::myConstructor,        // How to build the SOP
        HDK_Sample::SOP_SweepHDK::buildTemplates(),     // My parameters
        0,      // Min # of sources
        2,      // Max # of sources
        nullptr,// Custom local variables (none)
        0));    // No flags: not a generator, no merge input, not an output
}

namespace HDK_Sample {

OP_ERROR
SOP_SweepHDK::cookInputGroups(OP_Context &context, int alone)
{
    UT_ASSERT(alone);
    OP_AutoLockInputs inputs(this);
    if (inputs.lock(context) >= UT_ERROR_ABORT)
        return error();

    const GU_Detail *curve_input = inputGeo(theCurveInput);
    const GA_PrimitiveGroup *curve_group;
    OP_ERROR ret = cookInputPrimitiveGroups(context, curve_group, alone, true, 0, -1, true, false, GroupCreator(curve_input));
    if (ret >= UT_ERROR_ABORT)
        return ret;

    const GU_Detail *cross_section_input = inputGeo(theCrossSectionInput);
    const GA_PrimitiveGroup *cross_section_group;
    ret = cookInputPrimitiveGroups(context, cross_section_group, alone, true, 1, -1, true, false, GroupCreator(cross_section_input));
    return ret;
}

//******************************************************************************
//*                 Parameters                                                 *
//******************************************************************************

/// This is a multi-line raw string specifying the parameter interface for this SOP.
const char *const SOP_SweepHDKVerb::theDsFile = R"THEDSFILE(
{
    name        parameters
    parm {
        name    "curvegroup"
        cppname "CurveGroup"
        label   "Backbone Curve 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 geometry from an available viewport.\nShift-click to turn on Select Groups." }
        parmtag { "script_action_icon" "BUTTONS_reselect" }
    }
    parm {
        name    "crosssectiongroup"
        cppname "CrossSectionGroup"
        label   "Cross Section Group"
        type    string
        default { "" }
        parmtag { "script_action" "import soputils\nkwargs['geometrytype'] = (hou.geometryType.Primitives,)\nkwargs['inputindex'] = 1\nsoputils.selectGroupParm(kwargs)" }
        parmtag { "script_action_help" "Select geometry from an available viewport.\nShift-click to turn on Select Groups." }
        parmtag { "script_action_icon" "BUTTONS_reselect" }
    }
    parm {
        name    "sepparm"
        label   ""
        type    separator
        default { "" }
    }
    group {
        name    "surface_folder"
        label   "Surface"
        parm {
            name    "surfaceshape"
            cppname "SurfaceShape"
            label   "Surface Shape"
            type    ordinal
            default { "0" }     // Default to first entry in menu, "input"
            menu {
                "input"     "Second Input Cross Sections"
                "tube"      "Round Tube"
                "square"    "Square Tube"
                "ribbon"    "Ribbon"
            }
        }
        parm {
            name    "surfacetype"
            cppname "SurfaceType"
            label   "Surface Type"
            type    ordinal
            default { "5" }     // Default to menu entry "quads"
            menu {
                "points"    "Points"
                "rows"      "Rows"
                "cols"      "Columns"
                "rowcol"    "Rows and Columns"
                "tris"      "Triangles"
                "quads"     "Quadrilaterals"
                "alttris"   "Alternating Triangles"
                "revtris"   "Reverse Triangles"
            }
        }
        parm {
            name    "scale"
            label   "Scale Cross Sections"
            type    float
            default { "1" }
            range   { 0 4 }
            disablewhen "{ surfaceshape != input }"
            hidewhen    "{ surfaceshape != input }"
        }
        parm {
            name    "cols"
            label   "Columns"
            type    integer
            default { "8" }
            range   { 1! 24 }
            disablewhen "{ surfaceshape == input }"
            hidewhen    "{ surfaceshape == input }"
        }
        parm {
            name    "radius"
            label   "Radius"
            type    float
            default { "0.1" }
            range   { 0 1 }
            parmtag { "units" "m1" }
            disablewhen "{ surfaceshape != tube }"
            hidewhen    "{ surfaceshape != tube }"
        }
        parm {
            name    "width"
            label   "Width"
            type    float
            default { "0.2" }
            range   { 0 1 }
            parmtag { "units" "m1" }
            disablewhen "{ surfaceshape != ribbon surfaceshape != square }"
            hidewhen    "{ surfaceshape != ribbon surfaceshape != square }"
        }
        parm {
            name    "reversecrosssections"
            cppname "ReverseCrossSections"
            label   "Reverse Cross Sections"
            type    toggle
            default { "0" }
        }
        parm {
            name    "stretcharoundturns"
            cppname "StretchAroundTurns"
            label   "Stretch Around Turns"
            type    toggle
            default { "1" }
        }
        parm {
            name    "maxstretcharoundturns"
            cppname "MaxStretchAroundTurns"
            label   "Max Stretch"
            type    log
            default { "10" }
            range   { 1! 100 }
            disablewhen "{ stretcharoundturns == 0 }"
        }
        groupsimple {
            name    "endcaps_folder"
            label   "End Caps"
            parm {
                name    "endcaptype"
                cppname "EndCapType"
                label   "End Cap Type"
                type    ordinal
                default { "0" }     // Default to menu entry "none"
                menu {
                    "none"      "None"
                    "single"    "Single Polygon"
                    "grid"      "Grid"
                    "sidesingle" "Side Single Polygon"
                }
            }
            parm {
                name    "capdivs"
                cppname "CapDivs"
                label   "Cap Divisions"
                type    integer
                default { "3" }
                range   { 1! 10 }
                disablewhen "{ endcaptype == none } { endcaptype == single } { endcaptype == sidesingle }"
                hidewhen "{ endcaptype == none } { endcaptype == single } { endcaptype == sidesingle }"
                joinnext
            }
            parm {
                name    "triangularpoles"
                cppname "TriangularPoles"
                label   "Triangular Poles"
                type    toggle
                default { "0" }
                disablewhen "{ endcaptype == none } { endcaptype == single } { endcaptype == sidesingle }"
                hidewhen "{ endcaptype == none } { endcaptype == single } { endcaptype == sidesingle }"
            }
            parm {
                name    "capscale"
                cppname "CapScale"
                label   "End Cap Scale"
                type    float
                default { "1" }
                range   { 0 1 }
                disablewhen "{ endcaptype == none } { endcaptype == single } { endcaptype == sidesingle }"
                hidewhen "{ endcaptype == none } { endcaptype == single } { endcaptype == sidesingle }"
            }
            parm {
                name    "caproundness"
                cppname "CapRoundness"
                label   "End Cap Roundness"
                type    float
                default { "1" }
                range   { 0 1 }
                disablewhen "{ endcaptype == none } { endcaptype == single } { endcaptype == sidesingle }"
                hidewhen "{ endcaptype == none } { endcaptype == single } { endcaptype == sidesingle }"
            }
            parm {
                name    "addendcapsgroup"
                cppname "AddEndCapsGroup"
                label   "Add End Caps Group"
                type    toggle
                default { "0" }
                nolabel
                joinnext
            }
            parm {
                name    "endcapsgroup"
                cppname "EndCapsGroup"
                label   "End Caps Group"
                type    string
                default { "endcaps" }
                disablewhen "{ addendcapsgroup == 0 }"
            }
        }
        groupsimple {
            name    "scale_folder"
            label   "Scale"
            parm {
                name    "applyscale"
                cppname "ApplyScale"
                label   "Apply Scale Along Curve"
                type    toggle
                default { "0" }
            }
            parm {
                name    "scaleramp"
                cppname "ScaleRamp"
                label   "Scale Ramp"
                type    ramp_flt
                default { "2" }
                range   { 0! 10 }
                disablewhen "{ applyscale == 0 }"
                parmtag     { "rampfloatdefault" "1pos ( 0 ) 1value ( 1 ) 1interp ( linear ) 2pos ( 1 ) 2value ( 1 ) 2interp ( linear )" }
            }
        }
        groupsimple {
            name    "rotation_folder"
            label   "Rotation"
            parm {
                name    "rOrd"
                cppname "ROrd"
                label   "Rotate Order"
                type    ordinal
                // NOTE: The default rotation order X,Y,Z is semi-arbitrary, but Z
                //       should probably be last, since it always needs to twist
                //       around the curve tangent.  The X and Y rotations may have
                //       just been to reorient a cross-section before copying.
                default { "xyz" }
                menu {
                    "xyz"   "Pitch, Yaw, Roll"
                    "xzy"   "Pitch, Roll, Yaw"
                    "yxz"   "Yaw, Pitch, Roll"
                    "yzx"   "Yaw, Roll, Pitch"
                    "zxy"   "Roll, Pitch, Yaw"
                    "zyx"   "Roll, Yaw, Pitch"
                }
            }
            parm {
                name    "applyroll"
                cppname "ApplyRoll"
                label   "Apply Roll or Twist"
                type    toggle
                default { "1" }
            }
            parm {
                name    "roll"
                label   "Roll"
                type    float
                default { "0" }
                range   { -180 180 }
                hidewhen "{ applyroll == 0 }"
            }
            parm {
                name    "fulltwists"
                cppname "FullTwists"
                label   "Full Twists"
                type    integer
                default { "0" }
                range   { -10 10 }
                hidewhen "{ applyroll == 0 }"
            }
            parm {
                name    "incroll"
                cppname "IncRoll"
                label   "Partial Twist"
                type    float
                default { "0" }
                range   { -180 180 }
                hidewhen "{ applyroll == 0 }"
                joinnext
            }
            parm {
                name    "rollper"
                cppname "RollPer"
                label   "Twist Per"
                type    ordinal
                default { "4" }     // Default to "fulldistance" entry in menu
                menu {
                    "edge"          "Per Edge"
                    "distance"      "Per Unit Distance"
                    "attrib"        "Scale by Attribute"
                    "fulledges"     "Per Full Curve by Edges"
                    "fulldistance"  "Per Full Curve by Distance"
                }
                hidewhen "{ applyroll == 0 }"
            }
            parm {
                name    "rollattrib"
                cppname "RollAttrib"
                label   "Twist Ramp Attribute"
                type    string
                default { "roll" }
                disablewhen "{ applyroll == 0 } { applyroll == 1 rollper != attrib }"
                hidewhen    "{ applyroll == 0 } { applyroll == 1 rollper != attrib }"
            }
            parm {
                name    "sepparmroll"
                label   ""
                type    separator
                default { "" }
                hidewhen "{ applyroll == 0 }"
            }
            parm {
                name    "applyyaw"
                cppname "ApplyYaw"
                label   "Apply Yaw"
                type    toggle
                default { "0" }
            }
            parm {
                name    "yaw"
                label   "Yaw"
                type    float
                default { "0" }
                range   { -180 180 }
                hidewhen "{ applyyaw == 0 }"
            }
            parm {
                name    "incyaw"
                cppname "IncYaw"
                label   "Incremental Yaw"
                type    float
                default { "0" }
                range   { -180 180 }
                hidewhen "{ applyyaw == 0 }"
                joinnext
            }
            parm {
                name    "yawper"
                cppname "YawPer"
                label   "Yaw Per"
                type    ordinal
                default { "4" }     // Default to "fulldistance" entry in menu
                menu {
                    "edge"          "Per Edge"
                    "distance"      "Per Unit Distance"
                    "attrib"        "Scale By Attribute"
                    "fulledges"     "Per Full Curve by Edges"
                    "fulldistance"  "Per Full Curve by Distance"
                }
                hidewhen "{ applyyaw == 0 }"
            }
            parm {
                name    "yawattrib"
                cppname "YawAttrib"
                label   "Yaw Ramp Attribute"
                type    string
                default { "yaw" }
                disablewhen "{ applyyaw == 0 } { applyyaw == 1 yawper != attrib }"
                hidewhen    "{ applyyaw == 0 } { applyyaw == 1 yawper != attrib }"
            }
            parm {
                name    "sepparmyaw"
                label   ""
                type    separator
                default { "" }
                hidewhen "{ applyyaw == 0 }"
            }
            parm {
                name    "applypitch"
                cppname "ApplyPitch"
                label   "Apply Pitch"
                type    toggle
                default { "0" }
            }
            parm {
                name    "pitch"
                label   "Pitch"
                type    float
                default { "0" }
                range   { -180 180 }
                hidewhen "{ applypitch == 0 }"
            }
            parm {
                name    "incpitch"
                cppname "IncPitch"
                label   "Incremental Pitch"
                type    float
                default { "0" }
                range   { -180 180 }
                hidewhen "{ applypitch == 0 }"
                joinnext
            }
            parm {
                name    "pitchper"
                cppname "PitchPer"
                label   "Pitch Per"
                type    ordinal
                default { "4" }     // Default to "fulldistance" entry in menu
                menu {
                    "edge"          "Per Edge"
                    "distance"      "Per Unit Distance"
                    "attrib"        "Scale By Attribute"
                    "fulledges"     "Per Full Curve by Edges"
                    "fulldistance"  "Per Full Curve by Distance"
                }
                hidewhen "{ applypitch == 0 }"
            }
            parm {
                name    "pitchattrib"
                cppname "PitchAttrib"
                label   "Pitch Ramp Attribute"
                type    string
                default { "pitch" }
                disablewhen "{ applypitch == 0 } { applypitch == 1 pitchper != attrib }"
                hidewhen    "{ applypitch == 0 } { applypitch == 1 pitchper != attrib }"
            }
        }
    }
)THEDSFILE"
// ==== This is necessary because MSVC++ has a limit of 16380 character per
// ==== string literal
R"THEDSFILE(
    group {
        name    "construction_folder"
        label   "Construction"
        groupsimple {
            name    "cross_sections_folder"
            label   "Cross Sections"
            parm {
                name    "copyorder"
                cppname "CopyOrder"
                label   "Cross Section Order"
                type    ordinal
                default { "1" }     // Default to third entry in menu, "each"
                menu {
                    "all"   "All Cross Sections At Each Curve Vertex"
                    "each"  "Each Cross Section At All Curve Vertices"
                    "cyclevtx" "Cycle Through Cross Section Primitives per Vertex"
                    "cyclepr" "Cycle Through Cross Section Primitives per Curve"
                    "attrib" "Choose Cross Section Primitives by Attribute"
                }
                disablewhen "{ surfaceshape != input }"
            }
            parm {
                name    "crosssectionattrib"
                cppname "CrossSectionAttrib"
                label   "Cross Section Attribute"
                type    string
                default { "variant" }
                disablewhen "{ surfaceshape != input } { copyorder != attrib }"
                hidewhen    "{ surfaceshape != input } { copyorder != attrib }"
            }
            parm {
                name    "primtype"
                cppname "PrimType"
                label   "Primitive Type"
                type    ordinal
                default { "0" }     // Default to menu entry "auto"
                menu {
                    "auto"      "Automatic"
                    "poly"      "Polygons"
                    "mesh"      "Bilinear Mesh"
                    "nurbs"     "NURBS Surface"
                    "bezier"    "Bezier Surface"
                    "polysoup"  "Polygon Soup"
                }
                disablewhen "{ surfacetype == points }"
            }
            parm {
                name    "unrollclosedrowcol"
                cppname "UnrollClosedRowCol"
                label   "Ensure Unique Seam Vertices"
                type    toggle
                default { "0" }
                disablewhen "{ surfacetype == points }"
            }
            parm {
                name    "swaprowcol"
                cppname "SwapRowCol"
                label   "Swap Rows and Columns"
                type    toggle
                default { "0" }
            }
            parm {
                name    "closeifnocurveinput"
                cppname "CloseIfNoCurveInput"
                label   "Close Implicit Backbone Curve if No Curve Input"
                type    toggle
                default { "0" }
                disablewhen "{ surfacetype == points } { surfacetype == rows } { hasinput(0) != 0 }"
            }
            //parm {
            //    name    "segdivs"
            //    cppname "SegDivs"
            //    label   "Segment Divisions"
            //    type    integer
            //    default { "1" }
            //    range   { 1! 10 }
            //}
        }
        groupsimple {
            name    "up_folder"
            label   "Up Vectors"
            parm {
                name    "upvectortype"
                cppname "UpVectorType"
                label   "Target Up Vector"
                type    ordinal
                default { "0" } // Default to first entry in menu, "normal"
                menu {
                    "normal"    "Curve Normal"
                    "x"         "X Axis"
                    "y"         "Y Axis"
                    "z"         "Z Axis"
                    "attrib"    "Attribute"
                    "custom"    "Custom"
                }
                disablewhen "{ tangenttype == none }"
            }
            //parm {
            //    name    "usenormalup"
            //    cppname "UseNormalUp"
            //    label   "Use Curve Normal as Up Vector (When Valid)"
            //    type    toggle
            //    default { "1" }
            //    disablewhen "{ tangenttype == none }"
            //}
            parm {
                name    "upvectoratstart"
                cppname "UpVectorAtStart"
                label   "Target Up Vector at Start (else Average)"
                type    toggle
                default { "1" }
                disablewhen "{ tangenttype == none }"
            }
            parm {
                name    "useendupvector"
                cppname "UseEndUpVector"
                label   "Use Target End Up Vector"
                type    toggle
                default { "0" }
                disablewhen "{ tangenttype == none } { upvectoratstart == 0 }"
            }
            parm {
                name    "upvectorattrib"
                cppname "UpVectorAttrib"
                label   "Start Up Attribute"
                type    string
                default { "start_up" }
                disablewhen "{ tangenttype == none } { upvectortype != attrib }"
                hidewhen "{ tangenttype == none } { upvectortype != attrib }"
            }
            parm {
                name    "endupvectorattrib"
                cppname "EndUpVectorAttrib"
                label   "End Up Attribute"
                type    string
                default { "end_up" }
                disablewhen "{ tangenttype == none } { upvectortype != attrib } { useendupvector == 0 } { upvectoratstart == 0 }"
                hidewhen "{ tangenttype == none } { upvectortype != attrib } { useendupvector == 0 } { upvectoratstart == 0 }"
            }
            parm {
                name    "upvector"
                cppname "UpVector"
                label   "Start Up Vector"
                type    vector
                size    3
                default { "0" "1" "0" }
                disablewhen "{ tangenttype == none } { upvectortype != custom }"
                hidewhen "{ tangenttype == none } { upvectortype != custom }"
            }
            parm {
                name    "endupvector"
                cppname "EndUpVector"
                label   "End Up Vector"
                type    vector
                size    3
                default { "0" "1" "0" }
                disablewhen "{ tangenttype == none } { upvectortype != custom } { useendupvector == 0 } { upvectoratstart == 0 }"
                hidewhen "{ tangenttype == none } { upvectortype != custom } { useendupvector == 0 } { upvectoratstart == 0 }"
            }
        }
        groupsimple {
            name    "tangents_folder"
            label   "Tangents"
            parm {
                name    "tangenttype"
                cppname "TangentType"
                label   "Tangent Type"
                type    ordinal
                default { "0" } // Default to first entry in menu, "avgdir"
                menu {
                    "avgdir"    "Average of Edge Directions"
                    "diff"      "Central Difference"
                    "prev"      "Previous Edge"
                    "next"      "Next Edge"
                    "none"      "Z Axis (Ignore Curve)"
                }
            }
            parm {
                name    "continuousclosed"
                cppname "ContinuousClosed"
                label   "Make Closed Curve Orientations Continuous"
                type    toggle
                default { "1" }
                disablewhen "{ tangenttype == none }"
            }
            parm {
                name    "extrapolateendtangents"
                cppname "ExtrapolateEndTangents"
                label   "Extrapolate End Tangents"
                type    toggle
                default { "0" }
                disablewhen "{ tangenttype == none }"
            }
            parm {
                name    "transformbyattribs"
                cppname "TransformByAttribs"
                label   "Transform Using Curve Point Attributes"
                type    toggle
                default { "1" }
            }
        }
    }
)THEDSFILE"
// ==== This is necessary because MSVC++ has a limit of 16380 character per
// ==== string literal
R"THEDSFILE(
    group {
        name    "uvs_folder"
        label   "UVs and Attributes"
        groupsimple {
            name    "uv_folder"
            label   "UV Coordinates"
            parm {
                name    "computeuvs"
                cppname "ComputeUVs"
                label   "Compute UVs"
                type    toggle
                default { "0" }
            }
            parm {
                name    "overrideexistinguvs"
                cppname "OverrideExistingUVs"
                label   "Override Any Existing UVs"
                type    toggle
                default { "0" }
                disablewhen "{ computeuvs == 0 }"
            }
            parm {
                name    "lengthweighteduvs"
                cppname "LengthWeightedUVs"
                label   "Length-Weighted UVs"
                type    toggle
                default { "1" }
                disablewhen "{ computeuvs == 0 }"
            }
            parm {
                name    "normalizeu"
                cppname "NormalizeU"
                label   "Normalize Computed Us"
                type    toggle
                default { "1" }
                disablewhen "{ computeuvs == 0 } { lengthweighteduvs == 0 }"
            }
            parm {
                name    "normalizev"
                cppname "NormalizeV"
                label   "Normalize Computed Vs"
                type    toggle
                default { "0" }
                disablewhen "{ computeuvs == 0 } { lengthweighteduvs == 0 }"
            }
            parm {
                name    "flipu"
                cppname "FlipU"
                label   "Flip Computed Us"
                type    toggle
                default { "1" }
                disablewhen "{ computeuvs == 0 }"
            }
            groupcollapsible {
                name    "uvscale_folder"
                label   "UV Scale"
                grouptag { "group_type" "collapsible" }
                parmtag { "group_default" "0" }
                parm {
                    name    "uvscale"
                    cppname "UVScale"
                    label   "UV Scale"
                    type    float
                    size    2
                    default { "1" "1" }
                    disablewhen "{ computeuvs == 0 }"
                }
                parm {
                    name    "usemeshedgelengths"
                    cppname "UseMeshEdgeLengths"
                    label   "Use Mesh Edge Lengths Instead of Curve Edge Lengths"
                    type    toggle
                    default { "1" }
                    disablewhen "{ computeuvs == 0 } { lengthweighteduvs == 0 }"
                }
                parm {
                    name    "propscalepercurve"
                    cppname "PropScalePerCurve"
                    label   "Use Max Cross Section Length per Curve for Proportional Scale"
                    type    toggle
                    default { "1" }
                    disablewhen "{ computeuvs == 0 } { lengthweighteduvs == 0 } { normalizeu != 1 } { normalizev != 0 }"
                }
            }
            groupcollapsible {
                name    "uvseams_folder"
                label   "UV Seams"
                grouptag { "group_type" "collapsible" }
                parmtag { "group_default" "0" }
                parm {
                    name    "wrapu"
                    cppname "WrapU"
                    label   "Snap U to Nearest Tile Boundary"
                    type    toggle
                    default { "1" }
                    disablewhen "{ computeuvs == 0 } { lengthweighteduvs == 0 } { normalizeu == 1 }"
                }
                parm {
                    name    "wrapv"
                    cppname "WrapV"
                    label   "Snap V to Nearest Tile Boundary"
                    type    toggle
                    default { "1" }
                    disablewhen "{ computeuvs == 0 } { lengthweighteduvs == 0 } { normalizev == 1 }"
                }
            }
        }
        groupcollapsible {
            name    "attributes_folder"
            label   "Attributes"
            grouptag { "group_type" "collapsible" }
            parmtag { "group_default" "0" }
            groupsimple {
                name    "input_folder"
                label   "Input"
                parm {
                    name    "attribsfrombackbone"
                    cppname "AttribsFromBackbone"
                    label   "From Backbone Curves"
                    type    string
                    default { "* ^P ^N ^up ^pscale ^scale ^orient ^rot ^pivot ^trans ^transform" }
                }
                parm {
                    name    "attribsfromcrosssection"
                    cppname "AttribsFromCrossSection"
                    label   "From Cross Sections"
                    type    string
                    default { "*" }
                }
            }
            groupsimple {
                name    "output_folder"
                label   "Output"
                parm {
                    name    "addptrow"
                    cppname "AddPointRow"
                    label   "Add Point Row Attribute"
                    type    toggle
                    default { "0" }
                    nolabel
                    joinnext
                }
                parm {
                    name    "ptrowattrib"
                    cppname "PtRowAttrib"
                    label   "Point Row Attribute"
                    type    string
                    default { "ptrow" }
                    disablewhen "{ addptrow == 0 }"
                }
                parm {
                    name    "addptcol"
                    cppname "AddPointCol"
                    label   "Add Point Col Attribute"
                    type    toggle
                    default { "0" }
                    nolabel
                    joinnext
                }
                parm {
                    name    "ptcolattrib"
                    cppname "PtColAttrib"
                    label   "Point Col Attribute"
                    type    string
                    default { "ptcol" }
                    disablewhen "{ addptcol == 0 }"
                }
                parm {
                    name    "addprimrow"
                    cppname "AddPrimRow"
                    label   "Add Prim Row Attribute"
                    type    toggle
                    default { "0" }
                    nolabel
                    joinnext
                }
                parm {
                    name    "primrowattrib"
                    cppname "PrimRowAttrib"
                    label   "Prim Row Attribute"
                    type    string
                    default { "primrow" }
                    disablewhen "{ addprimrow == 0 }"
                }
                parm {
                    name    "addprimcol"
                    cppname "AddPrimCol"
                    label   "Add Prim Col Attribute"
                    type    toggle
                    default { "0" }
                    nolabel
                    joinnext
                }
                parm {
                    name    "primcolattrib"
                    cppname "PrimColAttrib"
                    label   "Prim Col Attribute"
                    type    string
                    default { "primcol" }
                    disablewhen "{ addprimcol == 0 }"
                }
                parm {
                    name    "addcrosssectionnum"
                    cppname "AddCrossSectionNum"
                    label   "Add Cross Section Num Attribute"
                    type    toggle
                    default { "0" }
                    nolabel
                    joinnext
                }
                parm {
                    name    "crosssectionnumattrib"
                    cppname "CrossSectionNumAttrib"
                    label   "Cross Section Num Attribute"
                    type    string
                    default { "crossnum" }
                    disablewhen "{ addcrosssectionnum == 0 }"
                }
                parm {
                    name    "addcurvenum"
                    cppname "AddCurveNum"
                    label   "Add Curve Num Attribute"
                    type    toggle
                    default { "0" }
                    nolabel
                    joinnext
                }
                parm {
                    name    "curvenumattrib"
                    cppname "CurveNumAttrib"
                    label   "Curve Num Attribute"
                    type    string
                    default { "curvenum" }
                    disablewhen "{ addcurvenum == 0 }"
                }
                // TODO: Add option to compute vertex normals with cusp angle.
            }
        }
    }
}
)THEDSFILE";

//******************************************************************************
//*                 Cooking                                                    *
//******************************************************************************

using namespace SOP_SweepHDKEnums;
using namespace GU_CurveFrame;

#if 0
/// This function takes edge lengths and a number of points to insert,
/// and determines the number of those points that should go in each edge
/// in order to minimize the maximum final interval length.
template<typename T>
static void
insertIntoIntervals(
    const T *const edge_lengths,
    const T total_length,
    const exint nedges,
    const exint ninsertions,
    exint *const ninsertions_per_edge)
{
    UT_ASSERT(nedges >= 1 && ninsertions >= 0);
    exint ninsertions_so_far = 0;
    for (exint i = 0; i < nedges; ++i)
    {
        T portion = (total_length > 0) ? (edge_lengths[i]/total_length) : (T(1)/T(nedges));
        // In exact arithmetic, the number of insertions in a given edge would
        // be at least floor(ninsertions*portion), but roundoff error could
        // cause problems, so subtract 1 to reduce the risk of the initial
        // number of insertions exceeding ninsertions.
        exint ki = SYSmax(exint(0), exint(SYSfloor(ninsertions*portion))-1);
        // Clamp it, just in case something weird happens.
        ki = SYSmin(ki, ninsertions-ninsertions_so_far);
        ninsertions_per_edge[i] = ki;
        ninsertions_so_far += ki;
    }
    if (ninsertions_so_far == ninsertions)
        return;

    struct IntervalComparator {
        IntervalComparator(const T *const edge_lengths, const exint *const ninsertions_per_edge) :
            myEdgeLengths(edge_lengths),
            myNInsertionsPerEdge(ninsertions_per_edge)
        {}
        bool operator()(const exint a, const exint b) const {
            // Compare the current lengths of the intervals along edge a vs those along edge b.
            // Multiply by both denomonators, instead of dividing, for better performance.
            const T nadb = myEdgeLengths[a]*(myNInsertionsPerEdge[b]+1);
            const T nbda = myEdgeLengths[b]*(myNInsertionsPerEdge[a]+1);

            // std::priority_queue is a max heap, and we want that, but the
            // comparator should act like std::less and return true if the
            // value for a is less than the value for b.
            // We also want a stable tie-breaker to avoid any problems with
            // different behaviour on different platforms.
            return nadb < nbda || (nadb == nbda && a < b);
        }
        const T *const myEdgeLengths;
        const exint *const myNInsertionsPerEdge;
    };
    IntervalComparator comparator(edge_lengths, ninsertions_per_edge);

    // Use n^2 approach for small nedges or small number of remaining
    // insertions, to avoid building a heap.
    if (nedges < 20 || (ninsertions-ninsertions_so_far) < 20) {
        do {
            exint edge_with_largest_intervals = 0;
            for (exint i = 1; i < nedges; ++i) {
                if (comparator(edge_with_largest_intervals, i)) {
                    edge_with_largest_intervals = i;
                }
            }
            ++ninsertions_per_edge[edge_with_largest_intervals];
            ++ninsertions_so_far;
        } while (ninsertions_so_far < ninsertions);

        return;
    }

    // Make a binary heap of edge indices such that the edge with
    // longest current intervals will be at the top.
    UT_Array<exint> heap;
    heap.setSizeNoInit(nedges);
    for (exint i = 0; i < nedges; ++i)
        heap(i) = i;
    exint *const heap_begin = heap.array();
    exint *const heap_end = heap_begin+nedges;
    std::make_heap(heap_begin, heap_end, comparator);

    while (true)
    {
        // Insert another point in the edge with the largest intervals.
        exint edge_with_largest_intervals = heap_begin[0];
        ++ninsertions_per_edge[edge_with_largest_intervals];
        ++ninsertions_so_far;
        if (ninsertions_so_far == ninsertions)
            return;

        // Update the heap
        std::pop_heap(heap_begin, heap_end, comparator);
        heap_end[-1] = edge_with_largest_intervals;
        std::push_heap(heap_begin, heap_end, comparator);
    }
}
#endif

static int
sopParmToPrimType(const SOP_SweepHDKEnums::PrimType sop_primtype)
{
    using PrimType = SOP_SweepHDKEnums::PrimType;
    switch (sop_primtype)
    {
        case PrimType::AUTO:    return GA_PRIMNONE;
        case PrimType::POLY:    return GA_PRIMPOLY;
        case PrimType::POLYSOUP:return GA_PRIMPOLYSOUP;
        case PrimType::MESH:    return GA_PRIMMESH;
        case PrimType::BEZIER:  return GA_PRIMBEZSURF;
        case PrimType::NURBS:   return GA_PRIMNURBSURF;
    }
    return GA_PRIMNONE;
}

static SYS_FORCE_INLINE exint
reverseVtx(exint i, exint n, bool closed)
{
    if (!closed)
        return (n-i-1);
    return (i==0) ? 0 : (n-i);
}

static void
computeCurveUVs(
    const GEO_Detail *detail,
    const GA_PrimitiveGroup *prim_group,
    const GA_RWHandleV3 &uv_attrib,
    bool by_length,
    bool reverse)
{
    // We're modifying this attribute, and it'll be in the output detail,
    // so we need to bump its data ID.
    uv_attrib->bumpDataId();

    // Because we're not parallelizing over vertex pages and we're writing
    // to a vertex attribute, we must harden all pages of the attribute in advance.
    uv_attrib->hardenAllPages();

    UT_AutoInterrupt interrupt("Computing curve UVs");
    if (interrupt.wasInterrupted())
        return;

    //const float fnprimitives = float(prim_group ? prim_group->entries() : detail->getNumPrimitives());

    // Loop over primitives in parallel, using a splittable range and a lambda functor.
    UTparallelFor(GA_SplittableRange(detail->getPrimitiveRange(prim_group)),
        [detail,&uv_attrib,&interrupt,by_length,reverse](const GA_SplittableRange &r)
    {
        // Inside the functor, we have a sub-range of primitives, so loop over that range.
        // We use blockAdvance, instead of !it.atEnd() and ++it, for less looping overhead.
        GA_Offset start; GA_Offset end;
        for (GA_Iterator it(r); it.blockAdvance(start,end); )
        {
            // We probably don't need to check for interruption on every curve,
            // (unless people put in a curve with millions of vertices), so we
            // can check it once for every contiguous block of up to GA_PAGE_SIZE
            // primitive offsets.
            if (interrupt.wasInterrupted())
                return;

            // Loop over all primitives in this contiguous block of offsets.
            for (GA_Offset primoff = start; primoff < end; ++primoff)
            {
                const GA_OffsetListRef vertices = detail->getPrimitiveVertexList(primoff);
                const GA_Size n = vertices.size();

                float v = 0;
                //if (separate_us)
                //    v = float(GA_Size(detail->primitiveIndex(primoff))) / fnprimitives;

                // Nothing to do if no vertices; special case if 1 vertex
                if (n <= 1)
                {
                    if (n == 1)
                        uv_attrib.set(vertices(0), UT_Vector3(0,v,0));
                    continue;
                }

                const bool closed = vertices.getExtraFlag();

                // Reversed closed polygons keep vertex 0 in the same place
                GA_Offset vtxoff0;
                if (!reverse || closed)
                    vtxoff0 = vertices(0);
                else
                    vtxoff0 = vertices(n-1);

                bool local_by_length = by_length;
                if (local_by_length)
                {
                    // First, compute the full length of the curve
                    float length = 0;
                    const UT_Vector3 pos0 = detail->getPos3(detail->vertexPoint(vtxoff0));
                    UT_Vector3 prev_pos = pos0;
                    for (GA_Size i = 1; i < n; ++i)
                    {
                        GA_Size vtxi = (!reverse) ? i : (n-i-!closed);
                        const UT_Vector3 cur_pos = detail->getPos3(detail->vertexPoint(vertices(vtxi)));
                        length += distance3d(prev_pos, cur_pos);
                        prev_pos = cur_pos;
                    }
                    if (closed)
                    {
                        // One last edge if closed
                        length += distance3d(prev_pos, pos0);
                    }
                    if (length == 0)
                    {
                        // Fall back to uniform weighting if total length is zero
                        local_by_length = false;
                    }
                    else
                    {
                        // Compute the u values as cur_length/length
                        uv_attrib.set(vtxoff0, UT_Vector3(0,v,0));
                        float cur_length = 0;
                        prev_pos = detail->getPos3(detail->vertexPoint(vtxoff0));
                        for (GA_Size i = 1; i < n; ++i)
                        {
                            GA_Size vtxi = (!reverse) ? i : (n-i-!closed);
                            GA_Offset vtxoff = vertices(vtxi);
                            const UT_Vector3 cur_pos = detail->getPos3(detail->vertexPoint(vtxoff));
                            cur_length += distance3d(prev_pos, cur_pos);
                            const float u = cur_length/length;
                            uv_attrib.set(vtxoff, UT_Vector3(u,v,0));
                            prev_pos = cur_pos;
                        }
                    }
                }
                if (!local_by_length)
                {
                    // Uniform uv step on each edge, so each u value is vertex/nedges
                    GA_Size nedges = closed ? n : (n-1);
                    uv_attrib.set(vtxoff0, UT_Vector3(0,v,0));
                    for (GA_Size i = 1; i < n; ++i)
                    {
                        GA_Size vtxi = (!reverse) ? i : (n-i-!closed);
                        const float u = i/float(nedges);
                        uv_attrib.set(vertices(vtxi), UT_Vector3(u,v,0));
                    }
                }

                // This is a silly way to do it, but to try to get UV wrapping
                // correct when reversing a closed cross section, the first U value
                // needs to be 1, instead of 0.  This is because of how code below
                // handles wrapping and closed cross sections from the cross section input.
                if (reverse && closed)
                {
                    uv_attrib.set(vtxoff0, UT_Vector3(1,v,0));
                }
            }
        }
    });
}

static GA_Offset lookupCrossSectionFromAttrib(
    const CrossSectionAttribMatchData *copy_order_attrib_data,
    GA_Offset curve_offset,
    const GEO_Detail *cross_section_input,
    const GA_PrimitiveGroup *cross_section_group)
{
    if (copy_order_attrib_data->myCurveIntAttrib.isValid())
    {
        // Integer attribute case
        const exint id = copy_order_attrib_data->myCurveIntAttrib.get(curve_offset);
        if (copy_order_attrib_data->myIsUsingMap) {
            // Using map (both inputs had integer attribute)
            if (UT::ArrayMap<exint,GA_Offset>::clearer_type::isClear(id)) {
                // No cross section, since invalid key for map type.
                return GA_INVALID_OFFSET;
            }
            auto &&it = copy_order_attrib_data->myIntToPrimOff.find(id);
            if (it == copy_order_attrib_data->myIntToPrimOff.end()) {
                // No cross section, since key not in map.
                return GA_INVALID_OFFSET;
            }
            return it->second;
        }
        if (id < 0 || id >= cross_section_input->getNumPrimitives()) {
            // No cross section, since primitive index out of range.
            return GA_INVALID_OFFSET;
        }
        const GA_Offset cross_section_primoff = cross_section_input->primitiveOffset(id);
        if (cross_section_group && !cross_section_group->contains(cross_section_primoff)) {
            // No cross section, since primitive not in group.
            return GA_INVALID_OFFSET;
        }
        return cross_section_primoff;
    }

    // String attribute case
    UT_ASSERT_P(copy_order_attrib_data->myCurveStrAttrib.isValid());
    UT_ASSERT_P(copy_order_attrib_data->myIsUsingMap);

    const UT_StringHolder &name = copy_order_attrib_data->myCurveStrAttrib.get(curve_offset);
    if (!name.isstring()) {
        // No cross section, since invalid key for map type.
        return GA_INVALID_OFFSET;
    }
    auto &&it = copy_order_attrib_data->myStrToPrimOff.find(name);
    if (it == copy_order_attrib_data->myStrToPrimOff.end()) {
        // No cross section, since key not in map.
        return GA_INVALID_OFFSET;
    }
    return it->second;
}

static int
updateAutoPrimType(
    const GEO_Detail *const cross_section_input,
    const GA_Offset cross_section_primoff,
    int &primitive_type,
    unsigned char &fallback_orderu,
    const GA_Basis **const pbasisu)
{
    UT_ASSERT_P(cross_section_input != nullptr);
    int primtype = cross_section_input->getPrimitiveTypeId(cross_section_primoff);
    // Only change if cross section is NURBS or Bezier curve.
    if (primtype != GA_PRIMNURBCURVE && primtype != GA_PRIMBEZCURVE)
        return primtype;

    // NURBS takes precedence, so don't modify if already NURBS
    if (primitive_type != GA_PRIMNURBSURF)
    {
        if (primtype == GA_PRIMNURBCURVE)
            primitive_type = GA_PRIMNURBSURF;
        else //if (primtype == GA_PRIMBEZCURVE)
            primitive_type = GA_PRIMBEZSURF;
    }

    const GEO_Curve *curve = UTverify_cast<const GEO_Curve *>(cross_section_input->getPrimitive(cross_section_primoff));
    UT_ASSERT_P(curve->getBasis() != nullptr);
    fallback_orderu = SYSmax(fallback_orderu, curve->getBasis()->getOrder());
    if (pbasisu != nullptr)
        *pbasisu = curve->getBasis();

    return primtype;
}

static bool
computeCombinedCrossSectionProperties(
    const GEO_Detail *const cross_section_input,
    const GA_PrimitiveGroup *const cross_section_group,
    GA_Iterator &cross_section_it,
    exint num_cross_sections,
    exint &cross_section_nedges,
    bool &cross_section_closed,
    bool &cross_section_unrolled,
    bool &varying_nedges,
    GA_OffsetList &cross_section_primoffs,
    const bool is_primtype_auto,
    int &primitive_type,
    unsigned char &fallback_orderu,
    const GA_Basis **const pbasisu)
{
    if (num_cross_sections == 0)
        return false;

    UT_ASSERT(cross_section_it.isValid());
    UT_ASSERT(!cross_section_it.atEnd());

    // If the final values of closed, unrolled, or primtype differ from
    // the values for the U basis, the U basis must be thrown out.
    bool basis_cross_section_closed;
    bool basis_cross_section_unrolled;
    int basis_primtype;

    cross_section_nedges = -1;
    varying_nedges = false;
    //bool varying_cross_section_topology = false;
    for (exint cross_sectioni = 0; cross_sectioni < num_cross_sections; ++cross_sectioni)
    {
        GA_Offset cross_section_primoff = *cross_section_it;
        ++cross_section_it;
        if (cross_section_it.atEnd())
        {
            // Wrap around the cross sections
            cross_section_it.rewind();
            UT_ASSERT(!cross_section_it.atEnd());
        }

        cross_section_primoffs.append(cross_section_primoff);
        const GA_OffsetListRef cross_section_vertices = cross_section_input->getPrimitiveVertexList(cross_section_primoff);
        exint local_cross_section_nedges;
        bool local_cross_section_closed;
        bool local_cross_section_unrolled;
        bool nonempty = getPolyProperties(cross_section_input, cross_section_vertices, local_cross_section_nedges, local_cross_section_closed, local_cross_section_unrolled);

        // If any cross section has no vertices, don't generate this grid at all.
        if (!nonempty)
            return false;

        if (cross_section_nedges == -1)
        {
            // First iteration, so copy value.
            cross_section_closed = local_cross_section_closed;
            cross_section_unrolled = local_cross_section_unrolled;
        }
        else if (!local_cross_section_closed)
        {
            //varying_cross_section_topology |= cross_section_closed || cross_section_unrolled;
            // If any cross section is open, we go with open.
            cross_section_closed = false;
            cross_section_unrolled = false;
        }
        else if (local_cross_section_unrolled && cross_section_closed && !cross_section_unrolled)
        {
            // If we're closed and not yet unrolled and we encounter
            // an unrolled cross section, go with unrolled.
            cross_section_unrolled = true;
            //varying_cross_section_topology = true;
        }

        // Independent of that, we choose the number of edges to be the max number of edges.
        bool local_varying_nedges = (cross_section_nedges != -1 && local_cross_section_nedges != cross_section_nedges);
        //varying_cross_section_topology |= local_varying_nedges;
        varying_nedges |= local_varying_nedges;

        int local_primtype;
        if (is_primtype_auto)
        {
            local_primtype = updateAutoPrimType(cross_section_input, cross_section_primoff, primitive_type, fallback_orderu, nullptr);
        }

        // Pick the maximum cross_section_nedges.
        if (local_cross_section_nedges > cross_section_nedges)
        {
            cross_section_nedges = local_cross_section_nedges;

            if (is_primtype_auto && pbasisu != nullptr)
            {
                // Choose the basis with the maximum nedges, since it's the most likely to be valid.
                if (local_primtype == GA_PRIMNURBCURVE || local_primtype == GA_PRIMBEZCURVE)
                {
                    basis_primtype = (local_primtype == GA_PRIMNURBCURVE) ? GA_PRIMNURBSURF : GA_PRIMBEZSURF;
                    basis_cross_section_closed = local_cross_section_closed;
                    basis_cross_section_unrolled = local_cross_section_unrolled;

                    const GEO_Curve *curve = UTverify_cast<const GEO_Curve*>(cross_section_input->getPrimitive(cross_section_primoff));
                    UT_ASSERT_P(curve->getBasis() != nullptr);
                    *pbasisu = curve->getBasis();
                }
                else
                {
                    // Not a NURBS or Bezier curve, so clear the basis.
                    *pbasisu = nullptr;
                }
            }
        }
    }

    if (pbasisu != nullptr && *pbasisu != nullptr)
    {
        // NOTE: This basis not be valid with the final
        //       cross_section_closed or cross_section_unrolled or primitive_type,
        //       so clear it if it's not valid.
        if (basis_primtype != primitive_type ||
            basis_cross_section_closed != cross_section_closed ||
            basis_cross_section_unrolled != cross_section_unrolled)
        {
            *pbasisu = nullptr;
        }
    }

    UT_ASSERT(cross_section_primoffs.size() > 0);

    return true;
}

// This is primarily the same as computeCombinedCrossSectionProperties,
// except selecting cross sections using copy_order_attrib_data,
// instead of getting sequential ones with a GA_Iterator.
static bool
computeCombinedCrossSectionPropertiesAttrib(
    const GEO_Detail *const cross_section_input,
    const GA_PrimitiveGroup *const cross_section_group,
    const GEO_Detail *const curve_input,
    const GA_OffsetListRef &curve_vertices,
    const CrossSectionAttribMatchData *const copy_order_attrib_data,
    exint &cross_section_nedges,
    bool &cross_section_closed,
    bool &cross_section_unrolled,
    bool &varying_nedges,
    GA_OffsetList &cross_section_primoffs,
    const bool is_primtype_auto,
    int &primitive_type,
    unsigned char &fallback_orderu,
    const GA_Basis **const pbasisu)
{
    exint num_vertices = curve_vertices.size();
    if (num_vertices == 0)
        return false;

    const GA_AttributeOwner curve_owner = copy_order_attrib_data->myCurveAttribOwner;
    UT_ASSERT(curve_owner == GA_ATTRIB_POINT || curve_owner == GA_ATTRIB_VERTEX);

    // If the final values of closed, unrolled, or primtype differ from
    // the values for the U basis, the U basis must be thrown out.
    bool basis_cross_section_closed;
    bool basis_cross_section_unrolled;
    int basis_primtype;

    cross_section_nedges = -1;
    varying_nedges = false;
    //bool varying_cross_section_topology = false;
    for (exint vtxi = 0; vtxi < num_vertices; ++vtxi)
    {
        GA_Offset curve_offset = curve_vertices[vtxi];
        if (curve_owner == GA_ATTRIB_POINT)
            curve_offset = curve_input->vertexPoint(curve_offset);
        GA_Offset cross_section_primoff = lookupCrossSectionFromAttrib(copy_order_attrib_data, curve_offset, cross_section_input, cross_section_group);

        // If any cross sections don't work out, give up on the grid,
        // for simplicity when copying curve attributes later.
        if (!GAisValid(cross_section_primoff))
            return false;

        cross_section_primoffs.append(cross_section_primoff);
        const GA_OffsetListRef cross_section_vertices = cross_section_input->getPrimitiveVertexList(cross_section_primoff);
        exint local_cross_section_nedges;
        bool local_cross_section_closed;
        bool local_cross_section_unrolled;
        bool nonempty = getPolyProperties(cross_section_input, cross_section_vertices, local_cross_section_nedges, local_cross_section_closed, local_cross_section_unrolled);

        // If any cross section has no vertices, don't generate this grid at all.
        if (!nonempty)
            return false;

        if (cross_section_nedges == -1)
        {
            // First iteration, so copy value.
            cross_section_closed = local_cross_section_closed;
            cross_section_unrolled = local_cross_section_unrolled;
        }
        else if (!local_cross_section_closed)
        {
            //varying_cross_section_topology |= cross_section_closed || cross_section_unrolled;
            // If any cross section is open, we go with open.
            cross_section_closed = false;
            cross_section_unrolled = false;
        }
        else if (local_cross_section_unrolled && cross_section_closed && !cross_section_unrolled)
        {
            // If we're closed and not yet unrolled and we encounter
            // an unrolled cross section, go with unrolled.
            cross_section_unrolled = true;
            //varying_cross_section_topology = true;
        }

        // Independent of that, we choose the number of edges to be the max number of edges.
        bool local_varying_nedges = (cross_section_nedges != -1 && local_cross_section_nedges != cross_section_nedges);
        //varying_cross_section_topology |= local_varying_nedges;
        varying_nedges |= local_varying_nedges;

        int local_primtype;
        if (is_primtype_auto)
        {
            local_primtype = updateAutoPrimType(cross_section_input, cross_section_primoff, primitive_type, fallback_orderu, nullptr);
        }

        // Pick the maximum cross_section_nedges.
        if (local_cross_section_nedges > cross_section_nedges)
        {
            cross_section_nedges = local_cross_section_nedges;

            if (is_primtype_auto && pbasisu != nullptr)
            {
                // Choose the basis with the maximum nedges, since it's the most likely to be valid.
                if (local_primtype == GA_PRIMNURBCURVE || local_primtype == GA_PRIMBEZCURVE)
                {
                    basis_primtype = (local_primtype == GA_PRIMNURBCURVE) ? GA_PRIMNURBSURF : GA_PRIMBEZSURF;
                    basis_cross_section_closed = local_cross_section_closed;
                    basis_cross_section_unrolled = local_cross_section_unrolled;

                    const GEO_Curve *curve = UTverify_cast<const GEO_Curve*>(cross_section_input->getPrimitive(cross_section_primoff));
                    UT_ASSERT_P(curve->getBasis() != nullptr);
                    *pbasisu = curve->getBasis();
                }
                else
                {
                    // Not a NURBS or Bezier curve, so clear the basis.
                    *pbasisu = nullptr;
                }
            }
        }
    }

    if (pbasisu != nullptr && *pbasisu != nullptr)
    {
        // NOTE: This basis not be valid with the final
        //       cross_section_closed or cross_section_unrolled or primitive_type,
        //       so clear it if it's not valid.
        if (basis_primtype != primitive_type ||
            basis_cross_section_closed != cross_section_closed ||
            basis_cross_section_unrolled != cross_section_unrolled)
        {
            *pbasisu = nullptr;
        }
    }

    UT_ASSERT(cross_section_primoffs.size() > 0);

    return true;
}

static void
initPrimType(
    const bool output_points_only,
    const bool is_primtype_auto,
    int &primitive_type,
    unsigned char &fallback_orderv,
    const GA_Basis **const pbasisv,
    const GEO_Detail *const curve_input,
    const GA_Offset curve_primoff)
{
    // When using automatic primitive type mode, we take the highest order NURBS,
    // or if the cross section with the most edges is Bezier, Bezier of that order;
    // 0 indicates that we haven't encountered any NURBS or Bezier curves yet.
    // NOTE: If primitive_type becomes GA_PRIMNURBSURF or GA_PRIMBEZSURF below,
    //       fallback_orderv should be set to something between 2 and GA_MAXORDER.
    fallback_orderv = 0;
    if (!is_primtype_auto)
        return;

    // Default guess is polygon
    primitive_type = GA_PRIMPOLY;
    if (curve_input == nullptr)
    {
        // If no curve, and cross sections end up having NURBS or Bezier,
        // default to order 4, instead of assuming implicit curve should be a polygon (order 2).
        fallback_orderv = 4;
        if (pbasisv)
            *pbasisv = nullptr;
        return;
    }

    const int curve_primtype = curve_input->getPrimitiveTypeId(curve_primoff);
    bool is_curve = false;
    if (curve_primtype == GA_PRIMBEZCURVE)
    {
        // If curve primitive is a Bezier curve, default guess is Bezier surface.
        primitive_type = GA_PRIMBEZSURF;
        is_curve = true;
    }
    else if (curve_primtype == GA_PRIMNURBCURVE)
    {
        // If curve primitive is a NURBS curve, always use NURBS surface
        // primitive if automatic mode.
        primitive_type = GA_PRIMNURBSURF;
        is_curve = true;
    }
    if (is_curve)
    {
        const GEO_Curve *const curve = UTverify_cast<const GEO_Curve *>(curve_input->getPrimitive(curve_primoff));
        if (pbasisv)
            *pbasisv = curve->getBasis();
        UT_ASSERT_P(curve->getBasis());
        fallback_orderv = curve->getBasis()->getOrder();
    }
}

// This fills in grid_info based on the input data.
// This function does *not* handle the copy cases; it only handles the grid cases.
// It returns false if the grid is invalid; the caller should not rely on grid_info or num_points in that case.
// NOTE: It does *not* fill in grid_info.myStartPtOff, grid_info.myStartVtxOff, or grid_info.myStartPrimOff.
static bool
computeSingleGridSetup(
    // Cross section parameters
    const GEO_Detail *const cross_section_input,
    const GA_PrimitiveGroup *const cross_section_group,
    const bool single_cross_section,
    GA_Iterator &cross_section_it,
    GA_Offset single_cross_section_primoff,
    exint cross_section_nedges,
    bool cross_section_closed,
    bool cross_section_unrolled,
    const CopyOrder copy_order,
    const CrossSectionAttribMatchData *const copy_order_attrib_data,
    bool varying_nedges_all_case,
    const GA_OffsetList *cross_section_primoffs_all_case,

    // Backbone curve parameters
    const GEO_Detail *const curve_input,
    const GA_Offset curve_primoff,
    const bool closed_if_no_curve_input,

    // Surface parameters
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool unroll_closed_row_col,
    const bool is_primtype_auto,
    int primitive_type,
    unsigned char fallback_orderu,
    unsigned char fallback_orderv,
    const GA_Basis **const pbasisu,
    EndCapType end_cap_type,
    exint cap_divisions,

    // Output parameters
    sop_SweepGrid &grid_info,
    exint &num_points)
{
    const bool has_col_surface_type =
        surface_type == GEO_PATCH_COLS ||
        surface_type == GEO_PATCH_ROWCOL;
    const bool has_row_surface_type =
        surface_type == GEO_PATCH_ROWS ||
        surface_type == GEO_PATCH_ROWCOL;
    const bool has_rowcol_surface_type =
        has_col_surface_type || has_row_surface_type;

    const bool is_polygon_type = (!output_points_only && primitive_type == GA_PRIMPOLY);
    const bool could_add_row_seam_vertex = (has_col_surface_type || !is_polygon_type) && unroll_closed_row_col;
    const bool could_add_col_seam_vertex = (has_row_surface_type || !is_polygon_type) && unroll_closed_row_col;

    if (curve_input == nullptr)
    {
        // Just input cross sections, no input curves, so only this one grid.
        UT_ASSERT(cross_section_input != nullptr);
        grid_info.myCurvePrimOff = GA_INVALID_OFFSET;
        grid_info.myCurveClosed = closed_if_no_curve_input;
        grid_info.myCurveUnrolled = (grid_info.myCurveClosed && could_add_row_seam_vertex);
        exint num_cross_sections = (cross_section_group ? cross_section_group->entries() : cross_section_input->getNumPrimitives());
        grid_info.myCurveNEdges = num_cross_sections - !grid_info.myCurveClosed;

        bool varying_nedges;
        GA_OffsetList cross_section_primoffs;
        bool is_valid_grid = computeCombinedCrossSectionProperties(
            cross_section_input,
            cross_section_group,
            cross_section_it,
            num_cross_sections,
            cross_section_nedges,
            cross_section_closed,
            cross_section_unrolled,
            varying_nedges,
            cross_section_primoffs,
            is_primtype_auto,
            primitive_type,
            fallback_orderu,
            pbasisu);

        if (!is_valid_grid)
            return false;

        grid_info.myCrossSectionNEdges = cross_section_nedges;
        grid_info.myCrossSectionClosed = cross_section_closed;
        grid_info.myCrossSectionUnrolled = cross_section_unrolled || (cross_section_closed && could_add_col_seam_vertex);
        grid_info.myAllEqualNEdges = !varying_nedges;
        grid_info.mySingleCrossSection = (cross_section_primoffs.size() == 1);
        if (grid_info.mySingleCrossSection)
            grid_info.myCrossSectionPrimOff = cross_section_primoffs(0);
        else
            grid_info.myCrossSectionPrimOffs = new GA_OffsetList(std::move(cross_section_primoffs));
    }
    else
    {
        // Input curve
        grid_info.myCurvePrimOff = curve_primoff;

        exint curve_nedges;
        bool curve_closed;
        bool curve_unrolled;
        const GA_OffsetListRef curve_vertices = curve_input->getPrimitiveVertexList(curve_primoff);
        bool nonempty = getPolyProperties(curve_input, curve_vertices, curve_nedges, curve_closed, curve_unrolled);

        // Skip curves with no vertices
        if (!nonempty)
            return false;

        grid_info.myCurveClosed = curve_closed;
        grid_info.myCurveUnrolled = curve_unrolled || (curve_closed && could_add_row_seam_vertex);
        grid_info.myCurveNEdges = curve_nedges;

        if (single_cross_section)
        {
            UT_ASSERT_MSG(copy_order != CopyOrder::ATTRIB, "This branch doesn't handle the possibility of invalid cross section selection in attribute.");
            grid_info.myCrossSectionNEdges = cross_section_nedges;
            grid_info.myCrossSectionClosed = cross_section_closed;
            grid_info.myCrossSectionUnrolled = cross_section_unrolled || (cross_section_closed && could_add_col_seam_vertex);
            grid_info.myAllEqualNEdges = true;
            grid_info.mySingleCrossSection = true;
            grid_info.myCrossSectionPrimOff = single_cross_section_primoff;
        }
        else
        {
            UT_ASSERT_MSG(copy_order == CopyOrder::CYCLEVTX || copy_order == CopyOrder::ALL || copy_order == CopyOrder::ATTRIB,
                "Other cases should have resolved to single cross section grids.");

            bool varying_nedges = varying_nedges_all_case;
            GA_OffsetList cross_section_primoffs;
            if (copy_order == CopyOrder::CYCLEVTX)
            {
                exint num_cross_sections = curve_nedges + !curve_closed;
                bool is_valid_grid = computeCombinedCrossSectionProperties(
                    cross_section_input,
                    cross_section_group,
                    cross_section_it,
                    num_cross_sections,
                    cross_section_nedges,
                    cross_section_closed,
                    cross_section_unrolled,
                    varying_nedges,
                    cross_section_primoffs,
                    is_primtype_auto,
                    primitive_type,
                    fallback_orderu,
                    pbasisu);

                if (!is_valid_grid)
                    return false;
            }
            else if (copy_order == CopyOrder::ATTRIB)
            {
                bool is_valid_grid = computeCombinedCrossSectionPropertiesAttrib(
                    cross_section_input,
                    cross_section_group,
                    curve_input,
                    curve_vertices,
                    copy_order_attrib_data,
                    cross_section_nedges,
                    cross_section_closed,
                    cross_section_unrolled,
                    varying_nedges,
                    cross_section_primoffs,
                    is_primtype_auto,
                    primitive_type,
                    fallback_orderu,
                    pbasisu);

                if (!is_valid_grid)
                    return false;
            }

            grid_info.myCrossSectionNEdges = cross_section_nedges;
            grid_info.myCrossSectionClosed = cross_section_closed;
            grid_info.myCrossSectionUnrolled = cross_section_unrolled || (cross_section_closed && could_add_col_seam_vertex);
            grid_info.myAllEqualNEdges = !varying_nedges;
            grid_info.mySingleCrossSection = false;
            if (copy_order == CopyOrder::ALL)
            {
                exint ncopies = grid_info.myCurveNEdges + !grid_info.myCurveClosed;
                grid_info.myCurveNEdges = (ncopies * cross_section_primoffs_all_case->size()) - !grid_info.myCurveClosed;
                grid_info.myCrossSectionPrimOffs = new GA_OffsetList();
                for (exint copyi = 0; copyi < ncopies; ++copyi)
                {
                    grid_info.myCrossSectionPrimOffs->append(*cross_section_primoffs_all_case);
                }
            }
            else
            {
                grid_info.myCrossSectionPrimOffs = new GA_OffsetList(std::move(cross_section_primoffs));
            }
        }
    }

    grid_info.myHasPolygonCaps =
        !output_points_only &&
        (
            (end_cap_type == EndCapType::SINGLE &&
                (!grid_info.myCurveClosed && grid_info.myCrossSectionClosed && grid_info.myCrossSectionNEdges > 1)) ||
            (end_cap_type == EndCapType::SIDESINGLE &&
                (!grid_info.myCrossSectionClosed && grid_info.myCurveClosed && grid_info.myCurveNEdges > 1))
        ) &&
        !has_rowcol_surface_type;

    // FIXME: Because we haven't sorted out how to represent transforms for U end caps yet, disable them for now!!!
    grid_info.myUEndPoles = false;
#if 0
    grid_info.myUEndPoles =
        !output_points_only &&
        (end_cap_type != EndCapType::NONE && end_cap_type != EndCapType::SINGLE && end_cap_type != EndCapType::SIDESINGLE) &&
        (!grid_info.myCrossSectionClosed && grid_info.myCurveClosed) &&
        cap_divisions > 0;
#endif

    // NOTE: Even non-closed cross sections can yield end "caps", so that
    //       it's possible to do rounded and pointed ends on ribbons.
    //       Even the flat case can be useful if the end cross section is not a straight line.
    grid_info.myVEndPoles =
        !output_points_only &&
        (end_cap_type != EndCapType::NONE && end_cap_type != EndCapType::SINGLE && end_cap_type != EndCapType::SIDESINGLE) &&
        (!grid_info.myCurveClosed) &&
        cap_divisions > 0;

    if (grid_info.myUEndPoles)
    {
        // Add in the divisions for the first and last col cap
        grid_info.myCrossSectionNEdges += 2*cap_divisions;

        // The first and last columns are collapsed to single points.
        UT_ASSERT(grid_info.myCurveNEdges >= 1);
    }
    else if (grid_info.myVEndPoles)
    {
        // Add in the divisions for the first and last row cap
        grid_info.myCurveNEdges += 2*cap_divisions;

        if (!grid_info.mySingleCrossSection)
        {
            // Add duplicates of first and last cross section primoffs for simplicity later.
            GA_OffsetList new_cross_section_primoffs;
            GA_OffsetList &primoffs = *grid_info.myCrossSectionPrimOffs;
            for (exint i = 0; i < cap_divisions; ++i)
                new_cross_section_primoffs.append(primoffs(0));
            new_cross_section_primoffs.append(primoffs);
            for (exint i = 0; i < cap_divisions; ++i)
                new_cross_section_primoffs.append(primoffs.last());
            primoffs = std::move(new_cross_section_primoffs);
        }

        // The first and last rows are collapsed to single points.
        UT_ASSERT(grid_info.myCrossSectionNEdges >= 1);
    }

    using PrimitiveType = sop_SweepGrid::PrimitiveType;
    grid_info.myPrimitiveType = PrimitiveType::POINTS;
    if (!output_points_only)
    {
        grid_info.myPrimitiveType = PrimitiveType::POLYGON;
        if (primitive_type == GA_PRIMPOLYSOUP)
            grid_info.myPrimitiveType = PrimitiveType::POLYSOUP;
        else if (primitive_type == GA_PRIMMESH)
            grid_info.myPrimitiveType = PrimitiveType::MESH;
        else if (primitive_type == GA_PRIMNURBSURF)
            grid_info.myPrimitiveType = PrimitiveType::NURBS;
        else if (primitive_type == GA_PRIMBEZSURF)
            grid_info.myPrimitiveType = PrimitiveType::BEZIER;

        // Fall back to polygon if number of rows or cols is too small.
        // TODO: Consider supporting outputting a single NURBS/Bezier curve.
        if (grid_info.myPrimitiveType != PrimitiveType::POLYGON &&
            (grid_info.myCurveNEdges <= 0 || grid_info.myCrossSectionNEdges <= 0))
        {
            grid_info.myPrimitiveType = PrimitiveType::POLYGON;
        }
    }
    if (grid_info.myPrimitiveType == PrimitiveType::NURBS)
    {
        if (fallback_orderv == 0)
        {
            // Either not auto, or curve was polygon but one of the cross sections was NURBS/Bezier.
            // Use order 2 if auto, since that's the closest match to polygon,
            // but use order 4 if not auto, since the user specifically chose NURBS.
            fallback_orderv = (is_primtype_auto && curve_input != nullptr) ? 2 : 4;
        }
        exint curve_nvertices = grid_info.myCurveNEdges + (!grid_info.myCurveClosed || grid_info.myCurveUnrolled);
        if (curve_nvertices < fallback_orderv)
        {
            // Too few vertices for fallback_orderv
            // Clamp just in case we made a mistake elsewhere with a closed 1-vertex curve having 1 edge.
            fallback_orderv = SYSclamp(int(curve_nvertices), 2, 3);
        }
        if (fallback_orderu == 0)
        {
            // Either not auto, or curve was NURBS but all of the cross sections were polygon.
            fallback_orderu = (is_primtype_auto && cross_section_input != nullptr) ? 2 : 4;
        }
        exint cross_section_nvertices = grid_info.myCrossSectionNEdges + (!grid_info.myCrossSectionClosed || grid_info.myCrossSectionUnrolled);
        if (cross_section_nvertices < fallback_orderu)
        {
            // Too few vertices for fallback_orderu
            // Clamp just in case we made a mistake elsewhere with a closed 1-vertex curve having 1 edge.
            fallback_orderu = SYSclamp(int(cross_section_nvertices), 2, 3);
        }
    }
    else if (grid_info.myPrimitiveType == PrimitiveType::BEZIER)
    {
        if (fallback_orderv == 0)
        {
            // Either not auto, or curve was polygon but one of the cross sections was Bezier.
            // Use order 2 if auto, since that's the closest match to polygon,
            // but use order 4 if not auto, since the user specifically chose Bezier.
            fallback_orderv = is_primtype_auto ? 2 : 4;
        }
        if (grid_info.myCurveNEdges % (fallback_orderv-1) != 0)
        {
            // Fall back to order 2, since number of edges isn't correct.
            fallback_orderv = 2;
        }
        if (fallback_orderu == 0)
        {
            // Either not auto, or curve was Bezier but all of the cross sections were polygon.
            fallback_orderu = is_primtype_auto ? 2 : 4;
        }
        if (grid_info.myCrossSectionNEdges % (fallback_orderu-1) != 0)
        {
            // Fall back to order 2, since number of edges isn't correct.
            fallback_orderu = 2;
        }
    }
    grid_info.myBasisOrderCrossSection = fallback_orderu;
    grid_info.myBasisOrderCurve = fallback_orderv;

    // Number of points, taking into account rows/cols that are collapsed into single points.
    num_points = (grid_info.myCurveNEdges + !grid_info.myCurveClosed - 2*exint(grid_info.myVEndPoles))
        * (grid_info.myCrossSectionNEdges + !grid_info.myCrossSectionClosed - 2*exint(grid_info.myUEndPoles))
        + 2*exint(grid_info.myVEndPoles) + 2*exint(grid_info.myUEndPoles);

    return true;
}

template<typename T>
static void
initGUGrid(
    const sop_SweepGrid &grid_info,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const bool swap_row_col,
    const T grid_start_ptnum,

    GU_GridT<T> &grid)
{
    grid.myTriangularPoles = triangular_poles;
    // TODO: Add support to GU_GridT for separate unrolled rows vs. unrolled cols.
    grid.myUnrollCurves = grid_info.myCurveUnrolled || grid_info.myCrossSectionUnrolled;
    grid.mySurfaceType = surface_type;
    using PrimitiveType = typename GU_GridT<T>::PrimitiveType;
    bool is_single_grid_prim = false;
    if (output_points_only)
        grid.myPrimitiveType = PrimitiveType::POINTS;
    else
    {
        grid.myPrimitiveType = PrimitiveType(int(grid_info.myPrimitiveType));
        is_single_grid_prim = (grid.myPrimitiveType != PrimitiveType::POLYGON);
    }

    grid.myFirstColIfNotWrapped = true;
    grid.myLastColIfNotWrapped = true;
    grid.myFirstRowIfNotWrapped = true;
    grid.myLastRowIfNotWrapped = true;
    grid.myCurvesIfBasisRowCol = true;

    const exint nedgerows = swap_row_col ? grid_info.myCrossSectionNEdges : grid_info.myCurveNEdges;
    const exint nedgecols = swap_row_col ? grid_info.myCurveNEdges : grid_info.myCrossSectionNEdges;
    bool vclosed = swap_row_col ? grid_info.myCrossSectionClosed : grid_info.myCurveClosed;
    bool uclosed = swap_row_col ? grid_info.myCurveClosed : grid_info.myCrossSectionClosed;
    bool uendpoles = swap_row_col ? grid_info.myVEndPoles : grid_info.myUEndPoles;
    bool vendpoles = swap_row_col ? grid_info.myUEndPoles : grid_info.myVEndPoles;
    if (is_single_grid_prim)
    {
        const exint nvtxrows = nedgerows + (!vclosed || grid.myUnrollCurves);
        const exint nvtxcols = nedgecols + (!uclosed || grid.myUnrollCurves);
        if (nvtxrows < 2 || nvtxcols < 2)
        {
            is_single_grid_prim = false;
            grid.myPrimitiveType = PrimitiveType::POLYGON;
        }
        else
        {
            unsigned char orderv = swap_row_col ? grid_info.myBasisOrderCrossSection : grid_info.myBasisOrderCurve;
            unsigned char orderu = swap_row_col ? grid_info.myBasisOrderCurve : grid_info.myBasisOrderCrossSection;
            grid.myBasisOrderV = orderv;
            grid.myBasisOrderU = orderu;
        }
    }
    if (vclosed)
    {
        if (uclosed)
            grid.initTorus(nedgerows, nedgecols, grid_start_ptnum);
        else if (!uendpoles)
            grid.initRowTube(nedgerows, nedgecols, grid_start_ptnum);
        else
        {
            grid.myFirstColIfNotWrapped = false;
            grid.myLastColIfNotWrapped = false;
            const exint nmid_points = nedgerows*(nedgecols - 1);
            grid.initRowSphere(nedgerows, nedgecols, grid_start_ptnum, grid_start_ptnum+1+nmid_points, grid_start_ptnum+1);
        }
    }
    else
    {
        if (uclosed)
        {
            if (!vendpoles)
                grid.initColTube(nedgerows, nedgecols, grid_start_ptnum);
            else
            {
                grid.myFirstRowIfNotWrapped = false;
                grid.myLastRowIfNotWrapped = false;
                const exint nmid_points = (nedgerows - 1)*nedgecols;
                grid.initColSphere(nedgerows, nedgecols, grid_start_ptnum, grid_start_ptnum+1+nmid_points, grid_start_ptnum+1);
            }
        }
        else
        {
            if (!vendpoles)
                grid.initSingleGrid(nedgerows, nedgecols, grid_start_ptnum);
            else
            {
                grid.myFirstRowIfNotWrapped = false;
                grid.myLastRowIfNotWrapped = false;
                const exint nmid_points = (nedgerows - 1)*(nedgecols+1);
                grid.initSplitColSphere(nedgerows, nedgecols, grid_start_ptnum, grid_start_ptnum+1+nmid_points, grid_start_ptnum+1);
            }
        }
    }
}

static void
appendPrimTypeCountPair(
    UT_Array<std::pair<int,exint>> &prim_type_count_pairs,
    int primtype,
    exint count)
{
    if (prim_type_count_pairs.isEmpty() || prim_type_count_pairs.last().first != primtype)
    {
        prim_type_count_pairs.append(std::pair<int,exint>(primtype, count));
    }
    else
    {
        prim_type_count_pairs.last().second += count;
    }
}

// NOTE: closed_span_lengths must be non-empty.  It can have an entry with value 0 instead.
//       createGrids always ensures that closed_span_lengths is not empty.
static void
appendClosedSpans(
    UT_Array<exint> &closed_span_lengths,
    bool closed)
{
    // Odd sizes (even indices) are for open polygon counts.
    // Even sizes (odd indices) are for closed polygon counts.
    if (!(closed_span_lengths.size() & 1) == closed)
        ++closed_span_lengths.last();
    else
        closed_span_lengths.append(1);
}

// appends to GEObuildPrimitives arrays, the info for building
// a single grid based on the data in grid_info.
// NOTE: num_grid_prims and num_grid_verts include caps.
static void
appendSingleGridTopology(
    const sop_SweepGrid &grid_info,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const bool single_polygon_caps,
    const bool swap_row_col,

    UT_Array<std::pair<int,exint>> &prim_type_count_pairs,
    //GA_Size &npoints, // npoints should already have been computed for grid_info
    GA_PolyCounts &vertexlistsizelist,
    UT_Array<exint> &vertexpointnumbers,
    UT_Array<exint> &closed_span_lengths,
    GA_Size &num_grid_prims,
    GA_Size &num_grid_verts)
{
    // Before creating the geometry, myStartPtOff is relative,
    // so just an exint, not a true GA_Offset.
    exint grid_start_ptnum = exint(grid_info.myStartPtOff);
    GU_GridT<exint> grid;
    initGUGrid(grid_info, surface_type, output_points_only, triangular_poles, swap_row_col, grid_start_ptnum, grid);

    num_grid_prims = grid.myNumPrimitives;
    num_grid_verts = grid.myNumVertices;

    if (num_grid_prims == 0)
        return;

    bool current_has_polygon_caps = grid_info.myHasPolygonCaps;
    bool is_row_cap = current_has_polygon_caps && grid.myNoWrapV;
    bool is_cross_section_cap = !grid_info.myCrossSectionClosed;
    exint cap_count = current_has_polygon_caps ? 2 : 0;

    int primtype = GA_PRIMPOLY;
    int cap_primtype = GA_PRIMPOLY;
    using PrimitiveType = GU_GridT<exint>::PrimitiveType;
    if (grid.myPrimitiveType == PrimitiveType::NURBS)
    {
        // FIXME: Take into account grid.myCurvesIfBasisRowCol when implemented!!!
        primtype = GA_PRIMNURBSURF;
        cap_primtype = GA_PRIMNURBCURVE;
    }
    else if (grid.myPrimitiveType == PrimitiveType::BEZIER)
    {
        // FIXME: Take into account grid.myCurvesIfBasisRowCol when implemented!!!
        primtype = GA_PRIMBEZSURF;
        cap_primtype = GA_PRIMBEZCURVE;
    }
    else if (grid.myPrimitiveType == PrimitiveType::MESH || grid.myPrimitiveType == PrimitiveType::POLYSOUP)
    {
        primtype = (grid.myPrimitiveType == PrimitiveType::MESH) ? GA_PRIMMESH : GA_PRIMPOLYSOUP;
        cap_primtype = GA_PRIMPOLY;
    }

    if (primtype == GA_PRIMPOLY || cap_count == 0)
    {
        appendPrimTypeCountPair(prim_type_count_pairs, primtype, num_grid_prims + cap_count);
    }
    else
    {
        appendPrimTypeCountPair(prim_type_count_pairs, cap_primtype, 1);
        appendPrimTypeCountPair(prim_type_count_pairs, primtype, num_grid_prims);
        appendPrimTypeCountPair(prim_type_count_pairs, cap_primtype, 1);
    }

    exint cap_vertex_count = 0;
    if (current_has_polygon_caps)
        cap_vertex_count = is_row_cap ? grid.myNumEdgeCols : grid.myNumEdgeRows;
    auto &&add_polygon_cap_functor = [is_row_cap,cap_vertex_count,swap_row_col,is_cross_section_cap,&grid,&vertexlistsizelist,&closed_span_lengths,&vertexpointnumbers](bool last_cap)
    {
        vertexlistsizelist.append(cap_vertex_count);

        // Single polygon caps are closed.
        appendClosedSpans(closed_span_lengths, true);

        const exint old_size = vertexpointnumbers.size();
        vertexpointnumbers.bumpSize(old_size + cap_vertex_count);
        exint *vertexpointnumber_start = vertexpointnumbers.getArray() + old_size;
        if (is_row_cap)
        {
            // First or last row
            exint row = last_cap ? grid.myNumEdgeRows : 0;
            for (exint col = 0; col < cap_vertex_count; ++col)
            {
                exint point_col = ((last_cap != swap_row_col) != is_cross_section_cap) ? col : reverseVtx(col, cap_vertex_count, true);
                vertexpointnumber_start[col] = grid.getPoint(row, point_col);
            }
        }
        else
        {
            // First or last column
            exint col = last_cap ? grid.myNumEdgeCols : 0;
            for (exint row = 0; row < cap_vertex_count; ++row)
            {
                exint point_row = ((last_cap != swap_row_col) != is_cross_section_cap) ? row : reverseVtx(row, cap_vertex_count, true);
                vertexpointnumber_start[row] = grid.getPoint(point_row, col);
            }
        }
    };
    if (current_has_polygon_caps)
    {
        // Start cap comes before main grid
        add_polygon_cap_functor(false);
    }

    // Add main grid primitives
    GUiterateGridPrimitives(grid,
        [&vertexlistsizelist,&closed_span_lengths
#if UT_ASSERT_LEVEL >= UT_ASSERT_LEVEL_PARANOID
        ,num_grid_prims
#endif
        ](exint primnum, exint row, exint col, exint primvtxcount, bool closed)
    {
        UT_ASSERT_P(primnum >= 0 && primnum < num_grid_prims);
        vertexlistsizelist.append(primvtxcount);

        appendClosedSpans(closed_span_lengths, closed);
    });

    const exint old_size = vertexpointnumbers.size();
    vertexpointnumbers.bumpSize(old_size + grid.myNumVertices);
    exint *vertexpointnumber_start = vertexpointnumbers.getArray() + old_size;
    GUiterateGridVertices(grid,
        [vertexpointnumber_start,&grid](exint vtxnum, exint row, exint col, bool isrowend, bool iscolend, exint primnum, exint primvtxnum)
    {
        UT_ASSERT_P(vtxnum >= 0 && vtxnum < grid.myNumVertices);
        vertexpointnumber_start[vtxnum] = grid.getPoint(row+exint(isrowend),col+exint(iscolend));
    });

    if (current_has_polygon_caps)
    {
        // End cap comes after main grid
        add_polygon_cap_functor(true);
    }

    // Make sure that caps are counted in num_grid_prims and num_grid_verts,
    // so that the caller knows the total for this grid (including caps).
    num_grid_prims += cap_count;
    num_grid_verts += 2*cap_vertex_count;
}

static void
initNonPolyGridPrims(
    const sop_SweepGrid &grid_info,
    const GU_GridT<GA_Offset> &grid,
    const bool swap_row_col,
    const GA_Basis *source_basisu,
    const GA_Basis *source_basisv,
    GEO_Detail *output_geo)
{
    using PrimitiveType = GU_GridT<GA_Offset>::PrimitiveType;
    if (grid.myPrimitiveType == PrimitiveType::POLYGON ||
        grid.myPrimitiveType == PrimitiveType::POINTS)
        return;

    GA_Offset primoff = grid_info.myStartPrimOff;
    if (grid_info.myHasPolygonCaps)
        ++primoff;

    GA_Primitive *prim = output_geo->getPrimitive(primoff);
    const exint nedgerows = grid.myNumEdgeRows;
    const exint nedgecols = grid.myNumEdgeCols;
    const bool hull_wrapv = grid.myAllWrapV && !grid.myUnrollCurves;
    const bool hull_wrapu = grid.myAllWrapU && !grid.myUnrollCurves;
    const exint nvtxrows = nedgerows + exint(!hull_wrapv);
    const exint nvtxcols = nedgecols + exint(!hull_wrapu);

    if (grid.myPrimitiveType == PrimitiveType::POLYSOUP)
    {
        GEO_PrimPolySoup *polysoup = UTverify_cast<GEO_PrimPolySoup *>(prim);

        // Iterate over the internal polygons
        sop_SweepGrid polygrid_info(grid_info);
        polygrid_info.myPrimitiveType = sop_SweepGrid::PrimitiveType::POLYGON;
        GU_GridT<GA_Offset> polygrid;
        initGUGrid(polygrid_info, grid.mySurfaceType, false, grid.myTriangularPoles, swap_row_col, polygrid_info.myStartPtOff, polygrid);

        GA_PolyCounts polygonsizes;
        GUiterateGridPrimitives(polygrid,
            [&polygonsizes](exint primnum, exint row, exint col, exint primvtxcount, bool closed)
        {
            polygonsizes.append(primvtxcount, 1);
        });

        // Preallocate memory for polygonvertexlist,
        // since it's unlikely to be trivial-compressed anyway.
        GA_OffsetList polygonvertexlist;
        polygonvertexlist.harden(polygrid.myNumVertices);

        // The following comment and two bool definitions were copied from GUiterateGridVertices.
        // "Unroll" in this case allows for UV seams.
        // FIXME: Does this need to take into account myFirstRowIfNotWrapped,
        //        myLastRowIfNotWrapped, myFirstColIfNotWrapped, myLastColIfNotWrapped
        //        if surface_type is rows or cols or rowcol?
        const bool has_endrow = grid.myNoWrapV || grid.myUnrollCurves;
        const bool has_endcol = grid.myNoWrapU || grid.myUnrollCurves;
        const exint nvtxcols = grid.myNumEdgeCols + exint(has_endcol);

        // Remember that the polygon soup primitive's vertices start after the first cap.
        exint cap_vertex_count = 0;
        if (grid_info.myHasPolygonCaps)
        {
            cap_vertex_count = !grid_info.myCurveClosed ? grid_info.myCrossSectionNEdges : grid_info.myCurveNEdges;
        }
        const GA_Offset start_vtxoff = grid_info.myStartVtxOff + cap_vertex_count;
        GUiterateGridVertices(polygrid,
            [&polygonvertexlist,start_vtxoff,&grid,has_endrow,has_endcol,nvtxcols](exint vtxnum, exint row, exint col,
                bool isrowend, bool iscolend, exint primnum, exint primvtxnum)
        {
            // NOTE: vtxnum is the vtxnum if it were polygons, but we need the vtxnum within the soup.
            if (isrowend)
            {
                if (!has_endrow && row == grid.myNumEdgeRows-1)
                    row = 0;
                else
                    ++row;
            }
            if (iscolend)
            {
                if (!has_endcol && col == grid.myNumEdgeCols-1)
                    col = 0;
                else
                    ++col;
            }
            exint soupvtxnum = row*nvtxcols + col;
            polygonvertexlist.append(start_vtxoff + soupvtxnum);
        });

        // This initializes GEO_PrimPolySoup::myPolygonSizes and myPolygonVertexList
        polysoup->appendPolygons(polygonsizes, polygonvertexlist);

        return;
    }

    // Bilinear mesh, NURBS surface, or Bezier surface
    GEO_Hull *hull = UTverify_cast<GEO_Hull *>(prim);
    hull->initHullData(nvtxrows, nvtxcols, hull_wrapv, hull_wrapu);
    hull->setSurfaceType(grid.mySurfaceType);

    const bool is_nurbs = (grid.myPrimitiveType == PrimitiveType::NURBS);
    const bool is_bezier = (grid.myPrimitiveType == PrimitiveType::BEZIER);
    if (!is_nurbs && !is_bezier)
        return;

    GEO_TPSurf *tpsurf = UTverify_cast<GEO_TPSurf *>(hull);

    GA_Basis *basisu = nullptr;
    GA_Basis *basisv = nullptr;

    GA_BASIS_TYPE basis_type = is_nurbs ? GA_NURBS_BASIS : GA_BEZIER_BASIS;
    if (source_basisu != nullptr && source_basisu->getType() != basis_type)
        source_basisu = nullptr;
    if (source_basisv != nullptr && source_basisv->getType() != basis_type)
        source_basisv = nullptr;

    // Copy any source basis
    if (source_basisu != nullptr)
    {
        basisu = GA_Basis::newSpecies(basis_type);
        basisu->copyFrom(*source_basisu);

        tpsurf->setUBasis(basisu);
        // NOTE: The "Ensure Unique Seam Vertices" option might mean
        //       the source basis isn't valid for the target.
        if (!tpsurf->getUBasis())
        {
            delete basisu;
            basisu = nullptr;
        }
    }
    if (source_basisv != nullptr)
    {
        basisv = GA_Basis::newSpecies(basis_type);
        basisv->copyFrom(*source_basisv);

        tpsurf->setVBasis(basisv);
        // NOTE: The "Ensure Unique Seam Vertices" option might mean
        //       the source basis isn't valid for the target.
        if (!tpsurf->getVBasis())
        {
            delete basisv;
            basisv = nullptr;
        }
    }

    if (is_nurbs)
    {
        auto &&make_nurbs_basis = [](exint nvertices, int order, bool closed) -> GA_NUBBasis*
        {
            // For now, we never end-interpolate closed cases.
            bool interpolate_ends = !closed;
            int extra_knots = order + (closed ? (interpolate_ends ? 1 : (order - 1)) : 0);
            // Number of knots = cvs+order.
            // However, if closed we need to add yet a few more knots:
            // 1 if interpEnds and order-1 otherwise
            return new GA_NUBBasis(0, 1,
                (nvertices + extra_knots),
                order,
                interpolate_ends);
        };

        if (basisu == nullptr)
        {
            basisu = make_nurbs_basis(nvtxcols, grid.myBasisOrderU, hull_wrapu);
            tpsurf->setUBasis(basisu);
            UT_ASSERT(tpsurf->getUBasis() != nullptr);
        }
        if (basisv == nullptr)
        {
            basisv = make_nurbs_basis(nvtxrows, grid.myBasisOrderV, hull_wrapv);
            tpsurf->setVBasis(basisv);
            UT_ASSERT(tpsurf->getVBasis() != nullptr);
        }
    }
    else
    {
        UT_ASSERT(is_bezier);

        auto &&make_bez_basis = [](exint nvertices, int order, bool closed) -> GA_BezBasis*
        {
            int extra = ((nvertices > 2 && order > 2) || (order <= 2 && closed));
            return new GA_BezBasis(0, 1,
                extra + (nvertices / (order - 1)),
                order);
        };
        if (basisu == nullptr)
        {
            basisu = make_bez_basis(nvtxcols, grid.myBasisOrderU, hull_wrapu);
            tpsurf->setUBasis(basisu);
            UT_ASSERT(tpsurf->getUBasis() != nullptr);
        }
        if (basisv == nullptr)
        {
            basisv = make_bez_basis(nvtxrows, grid.myBasisOrderV, hull_wrapv);
            tpsurf->setVBasis(basisv);
            UT_ASSERT(tpsurf->getVBasis() != nullptr);
        }
    }

    // setUBasis and setVBasis should always have succeeded,
    // because we created the bases correctly.
    UT_ASSERT(tpsurf->getUBasis() != nullptr);
    UT_ASSERT(tpsurf->getVBasis() != nullptr);

    if (grid_info.myHasPolygonCaps)
    {
        const bool side_caps = !grid_info.myCrossSectionClosed;
        const GA_Basis *cap_source_basis = (swap_row_col != side_caps) ? basisv : basisu;
        // Copy the U basis for each of the cap curves.
        GA_Basis *cap0_basis = GA_Basis::newSpecies(cap_source_basis->getType());
        GA_Basis *cap1_basis = GA_Basis::newSpecies(cap_source_basis->getType());
        cap0_basis->copyFrom(*cap_source_basis);
        cap1_basis->copyFrom(*cap_source_basis);
        // The caps are just before and just after the surface primitive.
        GEO_Curve *cap0 = UTverify_cast<GEO_Curve *>(output_geo->getPrimitive(primoff-1));
        GEO_Curve *cap1 = UTverify_cast<GEO_Curve *>(output_geo->getPrimitive(primoff+1));
        cap0->setBasis(cap0_basis);
        cap1->setBasis(cap1_basis);
    }
}

static bool
createGrids(
    const GEO_Detail *cross_section_input,
    const GA_PrimitiveGroup *cross_section_group,
    SurfaceShape cross_section_shape,
    exint cross_section_nedges,
    const CopyOrder copy_order,
    const CrossSectionAttribMatchData *const copy_order_attrib_data,

    const GEO_Detail *curve_input,
    const GA_PrimitiveGroup *curve_group,
    const bool closed_if_no_curve_input,

    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool unroll_closed_row_col,
    const int primitive_type,
    const EndCapType end_cap_type,
    const exint cap_divisions,
    const bool triangular_poles,
    const bool swap_row_col,

    GEO_Detail *output_geo,
    UT_Array<sop_SweepGrid> &grids)
{
    // Clear the array of grids.
    grids.setCapacity(0);

    // Destroy whatever was in the previous detail.
    output_geo->clearAndDestroy();

    UT_AutoInterrupt interrupt("Computing surface topology");
    if (interrupt.wasInterrupted())
        return false;

    // These arrays keep a pointer to the U or V basis of each grid,
    // if there are NURBS/Bezier curves or cross sections.
    UT_Array<const GA_Basis*> grid_basisus;
    UT_Array<const GA_Basis*> grid_basisvs;
    if (cross_section_input != nullptr && (
        cross_section_input->countPrimitiveType(GA_PRIMNURBCURVE) != 0 ||
        cross_section_input->countPrimitiveType(GA_PRIMBEZCURVE) != 0))
    {
        // Some grids may be invalid, so this will sometimes overallocate, but should be fine.
        exint max_num_grids = 1;
        if (curve_input != nullptr)
            max_num_grids = curve_group ? curve_group->entries() : curve_input->getNumPrimitives();
        grid_basisus.setSizeNoInit(max_num_grids);
        grid_basisus.constant(nullptr);
    }
    if (curve_input != nullptr && (
        curve_input->countPrimitiveType(GA_PRIMNURBCURVE) != 0 ||
        curve_input->countPrimitiveType(GA_PRIMBEZCURVE) != 0))
    {
        // Some grids may be invalid, so this will sometimes overallocate, but should be fine.
        const exint max_num_grids = curve_group ? curve_group->entries() : curve_input->getNumPrimitives();
        grid_basisvs.setSizeNoInit(max_num_grids);
        grid_basisvs.constant(nullptr);
    }

    bool single_cross_section = true;
    GA_Offset single_cross_section_primoff = GA_INVALID_OFFSET;
    bool cross_section_closed = (cross_section_shape == SurfaceShape::TUBE || cross_section_shape == SurfaceShape::SQUARE);
    bool cross_section_unrolled = false;
    GA_Range cross_section_range;
    if (cross_section_input != nullptr)
    {
        // If cross_section_group is null, this will be the whole range of primitives.
        cross_section_range = cross_section_input->getPrimitiveRange(cross_section_group);
        GA_Size ncross_sections = cross_section_range.getEntries();
        if (ncross_sections == 0)
        {
            // Nothing to do if no cross sections.
            // We must exit early, because code below assumes that there's
            // at least one cross section.
            return true;
        }
        // If selecting cross sections by attribute, there may be some invalid selections
        // that must be handled, even if there's only one valid selection.
        single_cross_section = (cross_section_range.getEntries() == 1 && copy_order != CopyOrder::ATTRIB);
        if (single_cross_section)
        {
            // Special case for a single cross section, since
            // it's a common case, and can be faster.
            GA_Iterator it(cross_section_range);
            UT_ASSERT(!it.atEnd());
            single_cross_section_primoff = *it;
            bool nonempty = getPolyProperties(cross_section_input, single_cross_section_primoff,
                cross_section_nedges, cross_section_closed, cross_section_unrolled);
            if (!nonempty)
                return true;
        }
    }

    GA_Iterator cross_section_it;
    if (!single_cross_section || curve_input == nullptr)
        cross_section_it = GA_Iterator(cross_section_range);

    const bool is_primtype_auto = !output_points_only && (primitive_type == GA_PRIMNONE);

    UT_SmallArray<std::pair<int,exint>,sizeof(std::pair<int,exint>)> prim_type_count_pairs;
    GA_PolyCounts vertexlistsizelist;
    UT_Array<exint> vertexpointnumbers;
    UT_SmallArray<exint,2*sizeof(exint)> closed_span_lengths;
    // Code in appendSingleGridTopology requires at least one initial entry in closed_span_lengths.
    closed_span_lengths.append(0);

    // TODO: If it's worthwhile for the no shared points case,
    //       take into account unrolling to determine hassharedpoints accurately.
    bool hassharedpoints = true;//(!output_points_only && surface_type != GEO_PATCH_COLS && surface_type != GEO_PATCH_ROWS);
    exint total_num_points = 0;
    exint total_num_verts = 0;
    exint total_num_prims = 0;
    if (curve_input == nullptr)
    {
        // No curve input, so just one grid of all cross sections.
        UT_ASSERT(cross_section_input != nullptr);

        UT_ASSERT(grid_basisvs.size() == 0);

        int local_primitive_type = primitive_type;
        unsigned char fallback_orderu = 0;
        unsigned char fallback_orderv;
        initPrimType(
            output_points_only,
            is_primtype_auto,
            local_primitive_type,
            fallback_orderv,
            nullptr,
            nullptr, GA_INVALID_OFFSET); // curve

        const GA_Basis **pbasisu = grid_basisus.isEmpty() ? nullptr : &grid_basisus[0];

        sop_SweepGrid grid_info;
        exint num_points;
        bool valid_grid = computeSingleGridSetup(
            cross_section_input,
            cross_section_group,
            false, // single_cross_section
            cross_section_it,
            GA_INVALID_OFFSET,
            0, false, false, CopyOrder::CYCLEVTX, nullptr, false, nullptr, // unused
            nullptr, GA_INVALID_OFFSET, // curve
            closed_if_no_curve_input,
            surface_type, output_points_only,
            unroll_closed_row_col,
            is_primtype_auto,
            local_primitive_type,
            fallback_orderu, fallback_orderv,
            pbasisu,
            end_cap_type,
            cap_divisions,
            grid_info, num_points);

        if (!valid_grid)
            return true;

        grid_info.myStartPtOff = GA_Offset(0);
        total_num_points = num_points;

        exint num_grid_prims;
        exint num_grid_verts;
        appendSingleGridTopology(
            grid_info, surface_type, output_points_only, triangular_poles,
            grid_info.myHasPolygonCaps, swap_row_col,
            prim_type_count_pairs, vertexlistsizelist, vertexpointnumbers,
            closed_span_lengths, num_grid_prims, num_grid_verts);

        grid_info.myStartVtxOff = GA_Offset(0);
        total_num_verts = num_grid_verts;
        grid_info.myStartPrimOff = GA_Offset(0);
        total_num_prims = num_grid_prims;
        grids.append(std::move(grid_info));
    }
    else if (!single_cross_section && copy_order == CopyOrder::EACH)
    {
        // For each cross section, loop over all curves.
        // FIXME: Parallelize this!!!
        for (; !cross_section_it.atEnd(); ++cross_section_it)
        {
            GA_Offset cross_section_primoff = *cross_section_it;

            bool nonempty = getPolyProperties(cross_section_input, cross_section_primoff,
                cross_section_nedges, cross_section_closed, cross_section_unrolled);
            if (!nonempty)
                continue;

            GA_Offset start;
            GA_Offset end;
            for (GA_Iterator it(curve_input->getPrimitiveRange(curve_group)); it.blockAdvance(start, end); )
            {
                if (interrupt.wasInterrupted())
                    return false;

                GA_Iterator invalid_it;

                for (GA_Offset curve_primoff = start; curve_primoff < end; ++curve_primoff)
                {
                    const exint gridi = grids.size();
                    const GA_Basis **pbasisu = grid_basisus.isEmpty() ? nullptr : &grid_basisus[gridi];
                    const GA_Basis **pbasisv = grid_basisvs.isEmpty() ? nullptr : &grid_basisvs[gridi];

                    int local_primitive_type = primitive_type;
                    unsigned char fallback_orderu = 0;
                    unsigned char fallback_orderv;
                    initPrimType(
                        output_points_only,
                        is_primtype_auto,
                        local_primitive_type,
                        fallback_orderv,
                        pbasisv,
                        curve_input,
                        curve_primoff);

                    // Single cross section, so primitive type must be handled in advance.
                    if (is_primtype_auto && cross_section_input != nullptr)
                        updateAutoPrimType(cross_section_input, cross_section_primoff, local_primitive_type, fallback_orderu, pbasisu);

                    sop_SweepGrid grid_info;
                    exint num_points;
                    bool valid_grid = computeSingleGridSetup(
                        nullptr, nullptr, // cross section resolved above
                        true,   // single_cross_section for this grid
                        invalid_it,
                        cross_section_primoff,
                        cross_section_nedges,
                        cross_section_closed,
                        cross_section_unrolled,
                        copy_order,
                        nullptr,// copy_order_attrib_data unused
                        false,  // varying_nedges_all_case unused
                        nullptr,// cross_section_primoffs_all_case unused
                        curve_input, curve_primoff,
                        false,  // closed_if_no_curve_input unused
                        surface_type,
                        output_points_only,
                        unroll_closed_row_col,
                        is_primtype_auto,
                        local_primitive_type,
                        fallback_orderu, fallback_orderv,
                        pbasisu,
                        end_cap_type,
                        cap_divisions,
                        grid_info,
                        num_points);

                    if (!valid_grid)
                        continue;

                    grid_info.myStartPtOff = GA_Offset(total_num_points);
                    total_num_points += num_points;

                    exint num_grid_prims;
                    exint num_grid_verts;
                    appendSingleGridTopology(
                        grid_info, surface_type, output_points_only, triangular_poles,
                        grid_info.myHasPolygonCaps, swap_row_col,
                        prim_type_count_pairs, vertexlistsizelist, vertexpointnumbers,
                        closed_span_lengths, num_grid_prims, num_grid_verts);

                    grid_info.myStartVtxOff = GA_Offset(total_num_verts);
                    total_num_verts += num_grid_verts;
                    grid_info.myStartPrimOff = GA_Offset(total_num_prims);
                    total_num_prims += num_grid_prims;
                    grids.append(std::move(grid_info));
                }
            }
        }
    }
    else if (!single_cross_section && (copy_order == CopyOrder::CYCLEPR ||
        (copy_order == CopyOrder::ATTRIB &&
            (copy_order_attrib_data->myCurveAttribOwner == GA_ATTRIB_DETAIL ||
                copy_order_attrib_data->myCurveAttribOwner == GA_ATTRIB_PRIMITIVE))))
    {
        // CopyOrder::CYCLEPR means "For each curve, pick the next cross section."
        // CopyOrder::ATTRIB has primitive or detail attribute on curve input selecting the cross section primitives in this case.
        GA_AttributeOwner curve_attrib_owner = (copy_order == CopyOrder::ATTRIB) ? copy_order_attrib_data->myCurveAttribOwner : GA_ATTRIB_INVALID;
        GA_Offset cross_section_primoff;
        if (curve_attrib_owner == GA_ATTRIB_DETAIL)
        {
            cross_section_primoff = lookupCrossSectionFromAttrib(copy_order_attrib_data,
                GA_DETAIL_OFFSET, cross_section_input, cross_section_group);
            // If no cross section for this detail, skip
            if (!GAisValid(cross_section_primoff))
                return true;
            bool nonempty = getPolyProperties(cross_section_input, cross_section_primoff,
                cross_section_nedges, cross_section_closed, cross_section_unrolled);
            if (!nonempty)
                return true;
        }

        GA_Offset start;
        GA_Offset end;
        for (GA_Iterator it(curve_input->getPrimitiveRange(curve_group)); it.blockAdvance(start, end); )
        {
            if (interrupt.wasInterrupted())
                return false;

            GA_Iterator invalid_it;

            for (GA_Offset curve_primoff = start; curve_primoff < end; ++curve_primoff)
            {
                if (copy_order == CopyOrder::CYCLEPR)
                {
                    cross_section_primoff = *cross_section_it;
                    ++cross_section_it;
                    if (cross_section_it.atEnd())
                    {
                        cross_section_it.rewind();
                        UT_ASSERT(!cross_section_it.atEnd());
                    }
                }
                else if (curve_attrib_owner == GA_ATTRIB_PRIMITIVE)
                {
                    cross_section_primoff = lookupCrossSectionFromAttrib(copy_order_attrib_data,
                        curve_primoff, cross_section_input, cross_section_group);
                    // If no cross section for this curve, skip
                    if (!GAisValid(cross_section_primoff))
                        continue;
                }

                if (curve_attrib_owner != GA_ATTRIB_DETAIL)
                {
                    bool nonempty = getPolyProperties(cross_section_input, cross_section_primoff,
                        cross_section_nedges, cross_section_closed, cross_section_unrolled);
                    if (!nonempty)
                        continue;
                }

                const exint gridi = grids.size();
                const GA_Basis **pbasisu = grid_basisus.isEmpty() ? nullptr : &grid_basisus[gridi];
                const GA_Basis **pbasisv = grid_basisvs.isEmpty() ? nullptr : &grid_basisvs[gridi];

                int local_primitive_type = primitive_type;
                unsigned char fallback_orderu = 0;
                unsigned char fallback_orderv;
                initPrimType(
                    output_points_only,
                    is_primtype_auto,
                    local_primitive_type,
                    fallback_orderv,
                    pbasisv,
                    curve_input,
                    curve_primoff);

                // Single cross section, so primitive type must be handled in advance.
                if (is_primtype_auto && cross_section_input != nullptr)
                    updateAutoPrimType(cross_section_input, cross_section_primoff, local_primitive_type, fallback_orderu, pbasisu);

                sop_SweepGrid grid_info;
                exint num_points;
                bool valid_grid = computeSingleGridSetup(
                    nullptr, nullptr, // cross section resolved above
                    true,   // single_cross_section for this grid
                    invalid_it,
                    cross_section_primoff,
                    cross_section_nedges,
                    cross_section_closed,
                    cross_section_unrolled,
                    copy_order,
                    nullptr,// copy_order_attrib_data unused
                    false,  // varying_nedges_all_case unused
                    nullptr,// cross_section_primoffs_all_case unused
                    curve_input, curve_primoff,
                    false,  // closed_if_no_curve_input unused
                    surface_type, output_points_only,
                    unroll_closed_row_col,
                    is_primtype_auto,
                    local_primitive_type,
                    fallback_orderu, fallback_orderv,
                    pbasisu,
                    end_cap_type,
                    cap_divisions,
                    grid_info, num_points);

                if (!valid_grid)
                    continue;

                grid_info.myStartPtOff = GA_Offset(total_num_points);
                total_num_points += num_points;

                exint num_grid_prims;
                exint num_grid_verts;
                appendSingleGridTopology(
                    grid_info, surface_type, output_points_only, triangular_poles,
                    grid_info.myHasPolygonCaps, swap_row_col,
                    prim_type_count_pairs, vertexlistsizelist, vertexpointnumbers,
                    closed_span_lengths, num_grid_prims, num_grid_verts);

                grid_info.myStartVtxOff = GA_Offset(total_num_verts);
                total_num_verts += num_grid_verts;
                grid_info.myStartPrimOff = GA_Offset(total_num_prims);
                total_num_prims += num_grid_prims;
                grids.append(std::move(grid_info));
            }
        }
    }
    else
    {
        unsigned char fallback_orderu = 0;
        int cross_section_primitive_type = is_primtype_auto ? GA_PRIMPOLY : primitive_type;
        bool varying_nedges_all_case = false;
        GA_OffsetList cross_section_primoffs_all_case;
        const bool all_case = (!single_cross_section && copy_order == CopyOrder::ALL);
        const GA_Basis *all_case_grid_basisu = nullptr;
        if (all_case)
        {
            // At each vertex, we'll want all cross sections.
            // To avoid having to recompute the cross section properties for every vertex,
            // iterate through all cross sections in advance.
            exint num_cross_sections = (cross_section_group ? cross_section_group->entries() : cross_section_input->getNumPrimitives());

            bool is_valid_grid = computeCombinedCrossSectionProperties(
                cross_section_input,
                cross_section_group,
                cross_section_it,
                num_cross_sections,
                cross_section_nedges,
                cross_section_closed,
                cross_section_unrolled,
                varying_nedges_all_case,
                cross_section_primoffs_all_case,
                is_primtype_auto,
                cross_section_primitive_type,
                fallback_orderu,
                &all_case_grid_basisu);

            if (!is_valid_grid)
                return true;
        }

        // FIXME: Parallelize this!!!
        GA_Offset start;
        GA_Offset end;
        for (GA_Iterator it(curve_input->getPrimitiveRange(curve_group)); it.blockAdvance(start, end); )
        {
            if (interrupt.wasInterrupted())
                return false;

            for (GA_Offset curve_primoff = start; curve_primoff < end; ++curve_primoff)
            {
                const exint gridi = grids.size();
                const GA_Basis **pbasisu = grid_basisus.isEmpty() ? nullptr : &grid_basisus[gridi];
                const GA_Basis **pbasisv = grid_basisvs.isEmpty() ? nullptr : &grid_basisvs[gridi];

                int local_primitive_type = primitive_type;
                unsigned char fallback_orderv;
                initPrimType(
                    output_points_only,
                    is_primtype_auto,
                    local_primitive_type,
                    fallback_orderv,
                    pbasisv,
                    curve_input,
                    curve_primoff);

                // If single cross section, primitive type must be handled in advance.
                if (single_cross_section && is_primtype_auto && cross_section_input != nullptr)
                    updateAutoPrimType(cross_section_input, single_cross_section_primoff, local_primitive_type, fallback_orderu, pbasisu);
                else if (all_case && local_primitive_type != GA_PRIMNURBSURF)
                {
                    if (cross_section_primitive_type == GA_PRIMNURBSURF || cross_section_primitive_type == GA_PRIMBEZSURF)
                        local_primitive_type = cross_section_primitive_type;
                }

                if (all_case && pbasisu != nullptr)
                {
                    // In the all cross sections at each vertex case,
                    // all grids have the same U basis.
                    *pbasisu = all_case_grid_basisu;
                }

                sop_SweepGrid grid_info;
                exint num_points;
                bool valid_grid = computeSingleGridSetup(
                    cross_section_input,
                    cross_section_group,
                    single_cross_section,
                    cross_section_it,
                    single_cross_section_primoff,
                    cross_section_nedges,
                    cross_section_closed,
                    cross_section_unrolled,
                    copy_order,
                    copy_order_attrib_data,
                    varying_nedges_all_case,
                    (cross_section_primoffs_all_case.size() == 0) ? nullptr : &cross_section_primoffs_all_case,
                    curve_input, curve_primoff,
                    closed_if_no_curve_input,
                    surface_type, output_points_only,
                    unroll_closed_row_col,
                    is_primtype_auto,
                    local_primitive_type,
                    fallback_orderu, fallback_orderv,
                    pbasisu,
                    end_cap_type,
                    cap_divisions,
                    grid_info, num_points);

                if (!valid_grid)
                    continue;

                grid_info.myStartPtOff = GA_Offset(total_num_points);
                total_num_points += num_points;

                exint num_grid_prims;
                exint num_grid_verts;
                appendSingleGridTopology(
                    grid_info, surface_type, output_points_only, triangular_poles,
                    grid_info.myHasPolygonCaps, swap_row_col,
                    prim_type_count_pairs, vertexlistsizelist, vertexpointnumbers,
                    closed_span_lengths, num_grid_prims, num_grid_verts);

                grid_info.myStartVtxOff = GA_Offset(total_num_verts);
                total_num_verts += num_grid_verts;
                grid_info.myStartPrimOff = GA_Offset(total_num_prims);
                total_num_prims += num_grid_prims;
                grids.append(std::move(grid_info));
            }
        }
    }

    if (interrupt.wasInterrupted())
        return false;

    // Create the geometry in output_geo
    GA_Offset start_ptoff = output_geo->appendPointBlock(total_num_points);
    GA_Offset start_vtxoff = GA_INVALID_OFFSET;
    GA_Offset start_primoff = GA_INVALID_OFFSET;
    if (output_points_only)
        output_geo->bumpDataIdsForAddOrRemove(true, false, false);
    else
    {
        start_primoff = GEObuildPrimitives(
            output_geo,
            prim_type_count_pairs.getArray(),
            start_ptoff, total_num_points,
            vertexlistsizelist, vertexpointnumbers.getArray(),
            hassharedpoints,
            closed_span_lengths.getArray());
        if (output_geo->getNumVertices() != 0)
            start_vtxoff = output_geo->vertexOffset(GA_Index(0));

        output_geo->bumpDataIdsForAddOrRemove(true, true, true);
    }

    // NOTE: Since there was never anything else in the detail, start_ptoff,
    //       start_primoff, and start_vtxoff should all be GA_Offset(0),
    //       but just in case we ever have anything before it, we'll write
    //       the code as if they could be anything.

    // Adjust all myStartPtOff, myStartVtxOff, and myStartPrimOff if starts aren't zero.
    if (start_ptoff != GA_Offset(0))
    {
        for (exint gridi = 0, num_grids = grids.size(); gridi < num_grids; ++gridi)
        {
            grids[gridi].myStartPtOff += start_ptoff;
        }
    }
    if (start_vtxoff != GA_INVALID_OFFSET && start_vtxoff != GA_Offset(0))
    {
        for (exint gridi = 0, num_grids = grids.size(); gridi < num_grids; ++gridi)
        {
            grids[gridi].myStartVtxOff += start_vtxoff;
        }
    }
    if (start_primoff != GA_INVALID_OFFSET && start_primoff != GA_Offset(0))
    {
        for (exint gridi = 0, num_grids = grids.size(); gridi < num_grids; ++gridi)
        {
            grids[gridi].myStartPrimOff += start_primoff;
        }
    }

    if (output_geo->getNumPrimitives() != output_geo->countPrimitiveType(GA_PRIMPOLY))
    {
        // There are non-polygon primitives, so we must initialize
        // primitive member data.
        for (exint gridi = 0, num_grids = grids.size(); gridi < num_grids; ++gridi)
        {
            const sop_SweepGrid &grid_info = grids[gridi];
            GU_GridT<GA_Offset> grid;
            initGUGrid(grid_info, surface_type, output_points_only, triangular_poles, swap_row_col, grid_info.myStartPtOff, grid);
            const GA_Basis *basisu = grid_basisus.isEmpty() ? nullptr : grid_basisus[gridi];
            const GA_Basis *basisv = grid_basisvs.isEmpty() ? nullptr : grid_basisvs[gridi];
            if (grid.myPrimitiveType != GU_GridT<GA_Offset>::PrimitiveType::POLYGON)
            {
                initNonPolyGridPrims(grid_info, grid, swap_row_col, basisu, basisv, output_geo);
            }
        }
    }

    return true;
}

template<typename FUNCTOR>
static void
copyVertexCrossSectionWrapper(
    const GU_GridT<GA_Offset> &grid,
    const sop_SweepGrid &grid_info,
    const FUNCTOR &functor)
{
    // FIXME: Is this function producing correct results when swap_row_col is true???!!!

    exint cap_vertex_count = 0;
    if (grid_info.myHasPolygonCaps)
    {
        if (grid.myNoWrapV)
        {
            // First row cap
            cap_vertex_count = grid.myNumEdgeCols;

            for (exint col = 0; col < cap_vertex_count; ++col)
            {
                // First cap is reversed
                functor(grid_info.myStartVtxOff + col, 0, reverseVtx(col, cap_vertex_count, true));
            }
        }
        else
        {
            // First side col cap
            cap_vertex_count = grid.myNumEdgeRows;

            for (exint row = 0; row < cap_vertex_count; ++row)
            {
                // First cap is reversed
                functor(grid_info.myStartVtxOff + row, reverseVtx(row, cap_vertex_count, true), 0);
            }
        }
    }
    // Main grid vertices
    const GA_Offset start_vtxoff = grid_info.myStartVtxOff + cap_vertex_count;
    auto &&functor_wrapper = [&functor,start_vtxoff](exint vtxnum, exint row, exint col, bool isrowend, bool iscolend, exint primnum, exint primvtxnum)
    {
        GA_Offset output_vtxoff = start_vtxoff + vtxnum;
        functor(output_vtxoff, row + exint(isrowend), col + exint(iscolend));
    };
    GUiterateGridVertices(grid, functor_wrapper);
    if (grid_info.myHasPolygonCaps)
    {
        // Last cap starts after main grid
        const GA_Offset cap_start_vtxoff = start_vtxoff + grid.myNumVertices;
        if (grid.myNoWrapV)
        {
            // Last row cap
            for (exint col = 0; col < cap_vertex_count; ++col)
            {
                functor(cap_start_vtxoff + col, grid.myNumEdgeRows, col);
            }
        }
        else
        {
            // Last side col cap
            for (exint row = 0; row < cap_vertex_count; ++row)
            {
                functor(cap_start_vtxoff + row, row, grid.myNumEdgeCols);
            }
        }
    }
}

template<typename TRANSFORM_T,GA_AttributeOwner output_attrib_owner,bool wrap_to_invalid=false,typename OUTPUT_ATTRIB_T,typename INPUT_ATTRIB_T,typename GET_TRANSFORM_FUNCTOR,typename TRANSFORM_FUNCTOR,typename INTERP_FUNCTOR>
static void
copyCrossSectionAttributeWrapper2(
    const GU_GridT<GA_Offset> &grid,
    const OUTPUT_ATTRIB_T &outputh,
    const INPUT_ATTRIB_T &cross_sectionh,
    const GA_AttributeOwner cross_section_owner,
    const GEO_Detail *cross_section_input,
    const sop_SweepGridTransformWrapper *transforms,
    const sop_SweepGrid &grid_info,
    const bool reverse_cross_sections,
    const bool swap_row_col,
    const GET_TRANSFORM_FUNCTOR &get_transform_functor,
    const TRANSFORM_FUNCTOR &transform_and_copy_functor,
    const INTERP_FUNCTOR &transform_and_interp_functor)
{
    UT_ASSERT(cross_section_owner != GA_ATTRIB_INVALID);
    UT_ASSERT(cross_section_owner == output_attrib_owner ||
        (cross_section_owner == GA_ATTRIB_POINT && output_attrib_owner == GA_ATTRIB_VERTEX) ||
        (cross_section_owner == GA_ATTRIB_VERTEX && output_attrib_owner == GA_ATTRIB_POINT));

    exint prev_curve_vtxi = -1;
    GA_Offset source_cross_section_primoff;
    GA_OffsetListRef cross_section_vertices;
    exint current_cross_section_nedges;
    bool current_cross_section_closed;
    bool current_cross_section_unrolled;
    const TRANSFORM_T *transform;
    auto &&functor = [&grid_info,&outputh,&cross_sectionh,
        cross_section_owner,
        &get_transform_functor,&transform_and_copy_functor,
        &transform_and_interp_functor,
        cross_section_input,
        transforms,
        reverse_cross_sections,
        swap_row_col,
        &prev_curve_vtxi,
        &source_cross_section_primoff,
        &cross_section_vertices,
        &current_cross_section_nedges,
        &current_cross_section_closed,
        &current_cross_section_unrolled,
        &transform](GA_Offset output_offset, exint row, exint col)
    {
        exint num_curve_edges = grid_info.myCurveNEdges;
        bool is_curve_closed = grid_info.myCurveClosed;
        exint curve_vtxi = swap_row_col ? col : row;
        exint num_cross_section_edges = grid_info.myCrossSectionNEdges;
        //bool is_cross_section_closed = grid_info.myCrossSectionClosed;
        exint cross_section_vtxi = swap_row_col ? row : col;

        if (curve_vtxi != prev_curve_vtxi)
        {
            // NOTE: This function is only for copying cross section attributes,
            //       so wrap_to_invalid only applies to column wrapping.
            //       Rows wrap normally when closed in this case.
            if (output_attrib_owner == GA_ATTRIB_VERTEX && is_curve_closed && curve_vtxi == num_curve_edges)
                curve_vtxi = 0;
            transform = get_transform_functor(transforms, curve_vtxi, grid_info);
            source_cross_section_primoff =
                grid_info.mySingleCrossSection ?
                GA_Offset(grid_info.myCrossSectionPrimOff) :
                (*grid_info.myCrossSectionPrimOffs)[curve_vtxi];
            UT_ASSERT_P(GAisValid(source_cross_section_primoff));
            if (output_attrib_owner != GA_ATTRIB_PRIMITIVE)
            {
                cross_section_vertices = cross_section_input->getPrimitiveVertexList(source_cross_section_primoff);
                getPolyProperties(cross_section_input, cross_section_vertices, current_cross_section_nedges, current_cross_section_closed, current_cross_section_unrolled);
            }
            prev_curve_vtxi = curve_vtxi;
        }

        if (output_attrib_owner == GA_ATTRIB_PRIMITIVE)
        {
            transform_and_copy_functor(cross_sectionh, source_cross_section_primoff, transform, outputh, output_offset);
            return;
        }

        constexpr bool is_vertex_attrib = (output_attrib_owner == GA_ATTRIB_VERTEX);

        if (current_cross_section_nedges == num_cross_section_edges)
        {
            // Copy from a single point.

            if (reverse_cross_sections)
            {
                // We handle wrapping below, so we reverse like an open polygon for all vertex attributes.
                cross_section_vtxi = reverseVtx(cross_section_vtxi, current_cross_section_nedges + exint(is_vertex_attrib || !current_cross_section_closed),
                    !is_vertex_attrib && current_cross_section_closed);
            }

            // NOTE: cross_section_vtxi may not be in-bounds, if this cross section is closed and some are open,
            //       since in that case, the grid will be open in that direction,
            //       so two output points will need to copy from vertex 0 of this cross section.
            GA_Offset vtxoff;
            if (cross_section_vtxi == cross_section_vertices.size())
            {
                if (wrap_to_invalid)
                {
                    // vertex UV attribute wraps to 1.0 value, not first value.
                    UT_ASSERT(is_vertex_attrib);
                    vtxoff = GA_INVALID_OFFSET;
                }
                else
                    vtxoff = cross_section_vertices[0];
            }
            else
                vtxoff = cross_section_vertices[cross_section_vtxi];
            GA_Offset cross_section_offset = (cross_section_owner == GA_ATTRIB_VERTEX || vtxoff == GA_INVALID_OFFSET) ? vtxoff : cross_section_input->vertexPoint(vtxoff);
            transform_and_copy_functor(cross_sectionh, cross_section_offset, transform, outputh, output_offset);
        }
        else
        {
            // Possibly interpolate between points.

            // The grid should have at least as many columns as the number of edges in each cross section.
            UT_ASSERT_P(num_cross_section_edges > current_cross_section_nedges);

            // Distribute the points evenly, but then snap the first point on a current edge
            // to the beginning of the edge and redistribute the points along that edge.
            // The division/modulus math is a bit hairy, but hopefully this works correctly.
            exint fine_fractions = cross_section_vtxi*current_cross_section_nedges;
            if (reverse_cross_sections)
                fine_fractions = num_cross_section_edges*current_cross_section_nedges - fine_fractions;
            exint current_cross_section_edge = fine_fractions / num_cross_section_edges;
            exint current_cross_section_fractions = fine_fractions % num_cross_section_edges;
            exint current_cross_section_pt = current_cross_section_fractions / current_cross_section_nedges;
            if (current_cross_section_pt == 0)
            {
                // First point on this edge: no need to interpolate, can just copy.
                GA_Offset vtxoff;
                if (current_cross_section_edge == cross_section_vertices.size())
                {
                    if (wrap_to_invalid)
                    {
                        // vertex UV attribute wraps to 1.0 value, not first value.
                        UT_ASSERT(is_vertex_attrib);
                        vtxoff = GA_INVALID_OFFSET;
                    }
                    else
                        vtxoff = cross_section_vertices[0];
                }
                else
                    vtxoff = cross_section_vertices[current_cross_section_edge];
                GA_Offset cross_section_offset = (cross_section_owner == GA_ATTRIB_VERTEX || vtxoff == GA_INVALID_OFFSET) ? vtxoff : cross_section_input->vertexPoint(vtxoff);
                transform_and_copy_functor(cross_sectionh, cross_section_offset, transform, outputh, output_offset);
            }
            else
            {
                // Partway along an edge: interpolate.
                // current_cross_section_edge_start is the smallest value of cross_section_vtxi that would yield current_cross_section_edge
                // current_cross_section_edge_end is the smallest value of cross_section_vtxi that would yield current_cross_section_edge+1
                // The difference is the number of points that will yield current_cross_section_edge
                exint current_cross_section_edge_start = (current_cross_section_edge*num_cross_section_edges + current_cross_section_nedges-1) / current_cross_section_nedges;
                exint current_cross_section_edge_end = ((current_cross_section_edge+1)*num_cross_section_edges + current_cross_section_nedges-1) / current_cross_section_nedges;
                exint current_cross_section_edge_npts = current_cross_section_edge_end - current_cross_section_edge_start;
                double u = double(current_cross_section_pt)/double(current_cross_section_edge_npts);

                // If current_cross_section_edge == current_cross_section_nedges,
                // the branch above to copy should have been taken.
                UT_ASSERT_P(current_cross_section_edge != current_cross_section_nedges);
                exint vtxi0 = current_cross_section_edge;
                GA_Offset vtxoff0 = cross_section_vertices[vtxi0];

                GA_Offset vtxoff1;
                if (current_cross_section_edge+1 == cross_section_vertices.size())
                {
                    if (wrap_to_invalid)
                    {
                        // vertex UV attribute wraps to 1.0 value, not first value.
                        UT_ASSERT(is_vertex_attrib);
                        vtxoff1 = GA_INVALID_OFFSET;
                    }
                    else
                        vtxoff1 = cross_section_vertices[0];
                }
                else
                    vtxoff1 = cross_section_vertices[current_cross_section_edge+1];

                GA_Offset cross_section_offset0;
                GA_Offset cross_section_offset1;
                if (cross_section_owner == GA_ATTRIB_VERTEX)
                {
                    cross_section_offset0 = vtxoff0;
                    cross_section_offset1 = vtxoff1;
                }
                else
                {
                    cross_section_offset0 = cross_section_input->vertexPoint(vtxoff0);
                    if (vtxoff1 != GA_INVALID_OFFSET)
                        cross_section_offset1 = cross_section_input->vertexPoint(vtxoff1);
                    else
                        cross_section_offset1 = vtxoff1;
                }
                transform_and_interp_functor(cross_sectionh, cross_section_offset0, cross_section_offset1, u, transform, outputh, output_offset);
            }
        }
    };

    SYS_STATIC_ASSERT(output_attrib_owner != GA_ATTRIB_DETAIL);

    if (output_attrib_owner == GA_ATTRIB_VERTEX)
    {
        copyVertexCrossSectionWrapper(grid, grid_info, functor);
    }
    else if (output_attrib_owner == GA_ATTRIB_POINT)
        GUiterateGridPoints(grid, functor);
    else
    {
        UT_ASSERT_P(output_attrib_owner == GA_ATTRIB_PRIMITIVE);
        if (grid_info.myHasPolygonCaps)
        {
            // First row/col cap
            functor(grid_info.myStartPrimOff, 0, 0);
        }
        // Main grid primitives
        const GA_Offset start_primoff = grid_info.myStartPrimOff + exint(grid_info.myHasPolygonCaps);
        auto &&functor_wrapper = [&functor,start_primoff](exint primnum, exint row, exint col, exint primvtxcount, bool closed)
        {
            GA_Offset output_primoff = start_primoff + primnum;
            functor(output_primoff, row, col);
        };
        GUiterateGridPrimitives(grid, functor_wrapper);
        if (grid_info.myHasPolygonCaps)
        {
            const GA_Offset cap_start_primoff = start_primoff + grid.myNumPrimitives;
            if (grid.myNoWrapV)
            {
                // Last row cap
                functor(cap_start_primoff, grid.myNumEdgeRows, 0);
            }
            else
            {
                // Last side col cap
                functor(cap_start_primoff, 0, grid.myNumEdgeCols);
            }
        }
    }
}

template<typename VALUE_T,typename TRANSFORM_T,GA_AttributeOwner attrib_owner,typename GET_TRANSFORM_FUNCTOR,typename TRANSFORM_FUNCTOR,typename INTERP_FUNCTOR>
static void
copyCrossSectionAttributeWrapper(
    GU_GridT<GA_Offset> &grid,
    GA_ATINumeric *output_attrib,
    const GA_ATINumeric *cross_section_attrib,
    const GEO_Detail *cross_section_input,
    const sop_SweepGridTransformWrapper *transforms,
    const sop_SweepGrid &grid_info,
    const bool reverse_cross_sections,
    const bool swap_row_col,
    const GET_TRANSFORM_FUNCTOR &get_transform_functor,
    const TRANSFORM_FUNCTOR &transform_and_copy_functor,
    const INTERP_FUNCTOR &transform_and_interp_functor)
{
    GA_RWHandleT<VALUE_T> outputh(output_attrib);
    GA_ROHandleT<VALUE_T> cross_sectionh(cross_section_attrib);
    UT_ASSERT_P(outputh.isValid());
    UT_ASSERT_P(cross_sectionh.isValid());
    UT_ASSERT(attrib_owner == cross_section_attrib->getOwner());
    copyCrossSectionAttributeWrapper2<TRANSFORM_T,attrib_owner>(
        grid, outputh, cross_sectionh, attrib_owner,
        cross_section_input, transforms, grid_info,
        reverse_cross_sections,
        swap_row_col,
        get_transform_functor,
        transform_and_copy_functor,
        transform_and_interp_functor);
}

template<typename T,GA_AttributeOwner attrib_owner>
static void
copyIntegerSingleGrid(
    GA_ATINumeric *output_attrib,
    const GA_ATINumeric *cross_section_attrib,
    const GEO_Detail *cross_section_input,
    const sop_SweepGridTransformWrapper *transforms,
    const sop_SweepGrid &grid_info,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const bool reverse_cross_sections,
    const bool swap_row_col)
{
    UT_ASSERT_P(cross_section_attrib != nullptr);
    UT_ASSERT_P(cross_section_input != nullptr);

    SYS_STATIC_ASSERT(std::is_integral<T>::value);

    GU_GridT<GA_Offset> grid;
    initGUGrid(grid_info, surface_type, output_points_only, triangular_poles, swap_row_col, grid_info.myStartPtOff, grid);

    const int tuple_size = output_attrib->getTupleSize();

    // Non-transforming cases follow
    auto &&get_transform = [](const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const void*
    {
        return nullptr;
    };

    if (tuple_size == 1)
    {
        // Copy single-component numeric attribute
        auto &&transform_and_copy = [](
            const GA_ROHandleT<T> &cross_sectionh, GA_Offset cross_section_offset,
            const void *transform,
            const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
        {
            T value = cross_sectionh.get(cross_section_offset);
            outputh.set(output_offset, value);
        };
        auto &&transform_and_interp = [](
            const GA_ROHandleT<T> &cross_sectionh,
            GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
            const void *transform,
            const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
        {
            GA_Offset cross_section_offset = (t < 0.5) ? cross_section_offset0 : cross_section_offset1;
            T value = cross_sectionh.get(cross_section_offset);
            outputh.set(output_offset, value);
        };
        copyCrossSectionAttributeWrapper<T, void, attrib_owner>(grid,
            output_attrib, cross_section_attrib, cross_section_input, transforms, grid_info,
            reverse_cross_sections, swap_row_col,
            get_transform, transform_and_copy, transform_and_interp);
        return;
    }

    // Copy arbitrary-component numeric attribute
    auto &&transform_and_copy = [tuple_size](
        const GA_ROHandleT<T> &cross_sectionh, GA_Offset cross_section_offset,
        const void *transform,
        const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
    {
        for (exint component = 0; component < tuple_size; ++component)
        {
            T value = cross_sectionh.get(cross_section_offset, component);
            outputh.set(output_offset, component, value);
        }
    };
    auto &&transform_and_interp = [tuple_size](
        const GA_ROHandleT<T> &cross_sectionh,
        GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, double t,
        const void *transform,
        const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
    {
        GA_Offset cross_section_offset = (t < 0.5) ? cross_section_offset0 : cross_section_offset1;
        for (exint component = 0; component < tuple_size; ++component)
        {
            T value = cross_sectionh.get(cross_section_offset, component);
            outputh.set(output_offset, component, value);
        }
    };
    copyCrossSectionAttributeWrapper<T, void, attrib_owner>(grid,
        output_attrib, cross_section_attrib, cross_section_input, transforms, grid_info,
        reverse_cross_sections, swap_row_col,
        get_transform, transform_and_copy, transform_and_interp);
}

template<typename T,GA_TypeInfo transform_type,GA_AttributeOwner attrib_owner>
static void
copyFloatSingleGrid(
    GA_ATINumeric *output_attrib,
    const GA_ATINumeric *cross_section_attrib,
    const GEO_Detail *cross_section_input,
    const sop_SweepGridTransformWrapper *transforms,
    const sop_SweepGrid &grid_info,
    const exint cross_sections_per_vertex,
    const exint cap_divisions,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const bool reverse_cross_sections,
    const bool swap_row_col)
{
    UT_ASSERT_P(cross_section_attrib != nullptr);
    UT_ASSERT_P(cross_section_input != nullptr);

    SYS_STATIC_ASSERT(!std::is_integral<T>::value);

    GU_GridT<GA_Offset> grid;
    initGUGrid(grid_info, surface_type, output_points_only, triangular_poles, swap_row_col, grid_info.myStartPtOff, grid);

    const exint cap_rows = (grid_info.myVEndPoles && !grid_info.myHasPolygonCaps) ? cap_divisions : 0;
    exint last_cap_start_row = -1;
    exint last_cap_start_transform = -1;
    if (cross_sections_per_vertex != 1 && cap_rows > 0)
    {
        last_cap_start_row = grid_info.myCurveNEdges - cap_rows;
        last_cap_start_transform = (last_cap_start_row - cap_rows)/cross_sections_per_vertex + cap_rows;
    }

    auto &&fix_transformi_for_all_case = [cap_rows,cross_sections_per_vertex,last_cap_start_row,last_cap_start_transform](exint &transformi)
    {
        // We have multiple cross sections per vertex, except in the caps,
        // when CopyOrder::ALL, but only one transform, so we need to
        // adjust transformi.
        if (cap_rows == 0)
            transformi /= cross_sections_per_vertex;
        else if (transformi > cap_rows)
        {
            if (transformi < last_cap_start_row)
                transformi = (transformi - cap_rows)/cross_sections_per_vertex + cap_rows;
            else
                transformi = last_cap_start_transform + (transformi - last_cap_start_row);
        }
    };

    const int tuple_size = output_attrib->getTupleSize();

    if (transforms)
    {
        if (transform_type == GA_TYPE_POINT)
        {
            // Transform position attribute
            UT_Matrix4T<T> transform;
            transform.identity();
            UT_ASSERT(tuple_size == 3);
            auto &&get_transform = [&transform,cross_sections_per_vertex,&fix_transformi_for_all_case]
                (const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const UT_Matrix4T<T>*
            {
                exint transformi = row;
                if (cross_sections_per_vertex != 1)
                    fix_transformi_for_all_case(transformi);
                transform = UT_Matrix4T<T>(transforms->getMatrix3s<T>()[transformi]);
                transform.setTranslates(transforms->getTranslates<T>()[transformi]);
                return &transform;
            };
            auto &&transform_and_copy = [](
                const GA_ROHandleT<UT_Vector3T<T>> &cross_sectionh, GA_Offset cross_section_offset,
                const UT_Matrix4T<T> *transform,
                const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
            {
                UT_Vector3T<T> value = cross_sectionh.get(cross_section_offset);
                value *= *transform;
                outputh.set(output_offset, value);
            };
            auto &&transform_and_interp = [](
                const GA_ROHandleT<UT_Vector3T<T>> &cross_sectionh,
                GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
                const UT_Matrix4T<T> *transform,
                const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
            {
                const UT_Vector3T<T> value0 = cross_sectionh.get(cross_section_offset0);
                const UT_Vector3T<T> value1 = cross_sectionh.get(cross_section_offset1);
                UT_Vector3T<T> value = SYSlerp(value0, value1, t);
                value *= *transform;
                outputh.set(output_offset, value);
            };
            copyCrossSectionAttributeWrapper<UT_Vector3T<T>, UT_Matrix4T<T>, attrib_owner>(grid,
                output_attrib, cross_section_attrib, cross_section_input, transforms, grid_info,
                reverse_cross_sections, swap_row_col,
                get_transform, transform_and_copy, transform_and_interp);
            return;
        }
        if (transform_type == GA_TYPE_NORMAL)
        {
            // Transform normal attribute
            UT_ASSERT(tuple_size == 3);
            auto &&get_transform = [cross_sections_per_vertex,&fix_transformi_for_all_case]
                (const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const UT_Matrix3T<T>*
            {
                exint transformi = row;
                if (cross_sections_per_vertex != 1)
                    fix_transformi_for_all_case(transformi);
                return &transforms->getInverse3s<T>()[transformi];
            };
            auto &&transform_and_copy = [](
                const GA_ROHandleT<UT_Vector3T<T>> &cross_sectionh, GA_Offset cross_section_offset,
                const UT_Matrix3T<T> *transform,
                const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
            {
                UT_Vector3T<T> value = cross_sectionh.get(cross_section_offset);
                value.colVecMult(*transform);
                outputh.set(output_offset, value);
            };
            auto &&transform_and_interp = [](
                const GA_ROHandleT<UT_Vector3T<T>> &cross_sectionh,
                GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
                const UT_Matrix3T<T> *transform,
                const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
            {
                const UT_Vector3T<T> value0 = cross_sectionh.get(cross_section_offset0);
                const UT_Vector3T<T> value1 = cross_sectionh.get(cross_section_offset1);

                // FIXME: slerp, instead of lerping and normalizing!!!
                UT_Vector3T<T> value = SYSlerp(value0, value1, t);
                value.normalize();

                T orig_length2 = value.length2();
                value.colVecMult(*transform);
                T new_length2 = value.length2();
                // Preserve normal length
                if (new_length2 != 0)
                    value *= SYSsqrt(orig_length2/new_length2);
                outputh.set(output_offset, value);
            };
            copyCrossSectionAttributeWrapper<UT_Vector3T<T>, UT_Matrix3T<T>, attrib_owner>(grid,
                output_attrib, cross_section_attrib, cross_section_input, transforms, grid_info,
                reverse_cross_sections, swap_row_col,
                get_transform, transform_and_copy, transform_and_interp);
            return;
        }
        if (transform_type == GA_TYPE_VECTOR)
        {
            // Transform vector attribute
            UT_ASSERT(tuple_size == 3);
            auto &&get_transform = [cross_sections_per_vertex,&fix_transformi_for_all_case]
                (const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const UT_Matrix3T<T>*
            {
                exint transformi = row;
                if (cross_sections_per_vertex != 1)
                    fix_transformi_for_all_case(transformi);
                return &transforms->getMatrix3s<T>()[transformi];
            };
            auto &&transform_and_copy = [](
                const GA_ROHandleT<UT_Vector3T<T>> &cross_sectionh, GA_Offset cross_section_offset,
                const UT_Matrix3T<T> *transform,
                const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
            {
                UT_Vector3T<T> value = cross_sectionh.get(cross_section_offset);
                value *= *transform;
                outputh.set(output_offset, value);
            };
            auto &&transform_and_interp = [](
                const GA_ROHandleT<UT_Vector3T<T>> &cross_sectionh,
                GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
                const UT_Matrix3T<T> *transform,
                const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
            {
                const UT_Vector3T<T> value0 = cross_sectionh.get(cross_section_offset0);
                const UT_Vector3T<T> value1 = cross_sectionh.get(cross_section_offset1);
                UT_Vector3T<T> value = SYSlerp(value0, value1, t);
                value *= *transform;
                outputh.set(output_offset, value);
            };
            copyCrossSectionAttributeWrapper<UT_Vector3T<T>, UT_Matrix3T<T>, attrib_owner>(grid,
                output_attrib, cross_section_attrib, cross_section_input, transforms, grid_info,
                reverse_cross_sections, swap_row_col,
                get_transform, transform_and_copy, transform_and_interp);
            return;
        }
        if (transform_type == GA_TYPE_QUATERNION)
        {
            // Transform vector attribute
            UT_ASSERT(tuple_size == 4);
            auto &&get_transform = [cross_sections_per_vertex,&fix_transformi_for_all_case]
                (const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const UT_QuaternionT<T>*
            {
                exint transformi = row;
                if (cross_sections_per_vertex != 1)
                    fix_transformi_for_all_case(transformi);
                return &transforms->getQuaternions<T>()[transformi];
            };
            auto &&transform_and_copy = [](
                const GA_ROHandleT<UT_QuaternionT<T>> &cross_sectionh, GA_Offset cross_section_offset,
                const UT_QuaternionT<T> *transform,
                const GA_RWHandleT<UT_QuaternionT<T>> &outputh, GA_Offset output_offset)
            {
                UT_QuaternionT<T> value = cross_sectionh.get(cross_section_offset);
                value *= *transform;
                outputh.set(output_offset, value);
            };
            auto &&transform_and_interp = [](
                const GA_ROHandleT<UT_QuaternionT<T>> &cross_sectionh,
                GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
                const UT_QuaternionT<T> *transform,
                const GA_RWHandleT<UT_QuaternionT<T>> &outputh, GA_Offset output_offset)
            {
                const UT_QuaternionT<T> value0 = cross_sectionh.get(cross_section_offset0);
                const UT_QuaternionT<T> value1 = cross_sectionh.get(cross_section_offset1);
                UT_QuaternionT<T> value = value0;
                value.interpolate(value1, t);
                value = *transform * value;
                outputh.set(output_offset, value);
            };
            copyCrossSectionAttributeWrapper<UT_QuaternionT<T>, UT_QuaternionT<T>, attrib_owner>(grid,
                output_attrib, cross_section_attrib, cross_section_input, transforms, grid_info,
                reverse_cross_sections, swap_row_col,
                get_transform, transform_and_copy, transform_and_interp);
            return;
        }
        if (transform_type == GA_TYPE_TRANSFORM)
        {
            if (tuple_size == 9)
            {
                // Transform 3x3 matrix attribute
                auto &&get_transform = [cross_sections_per_vertex,&fix_transformi_for_all_case]
                    (const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const UT_Matrix3T<T>*
                {
                    exint transformi = row;
                    if (cross_sections_per_vertex != 1)
                        fix_transformi_for_all_case(transformi);
                    return &transforms->getMatrix3s<T>()[transformi];
                };
                auto &&transform_and_copy = [](
                    const GA_ROHandleT<UT_Matrix3T<T>> &cross_sectionh, GA_Offset cross_section_offset,
                    const UT_Matrix3T<T> *transform,
                    const GA_RWHandleT<UT_Matrix3T<T>> &outputh, GA_Offset output_offset)
                {
                    UT_Matrix3T<T> value = cross_sectionh.get(cross_section_offset);
                    value *= *transform;
                    outputh.set(output_offset, value);
                };
                auto &&transform_and_interp = [](
                    const GA_ROHandleT<UT_Matrix3T<T>> &cross_sectionh,
                    GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
                    const UT_Matrix3T<T> *transform,
                    const GA_RWHandleT<UT_Matrix3T<T>> &outputh, GA_Offset output_offset)
                {
                    const UT_Matrix3T<T> value0 = cross_sectionh.get(cross_section_offset0);
                    const UT_Matrix3T<T> value1 = cross_sectionh.get(cross_section_offset1);
                    UT_Matrix3T<T> value = SYSlerp(value0, value1, t);
                    value *= *transform;
                    outputh.set(output_offset, value);
                };
                copyCrossSectionAttributeWrapper<UT_Matrix3T<T>, UT_Matrix3T<T>, attrib_owner>(grid,
                    output_attrib, cross_section_attrib, cross_section_input, transforms, grid_info,
                    reverse_cross_sections, swap_row_col,
                    get_transform, transform_and_copy, transform_and_interp);
                return;
            }
            if (tuple_size == 16)
            {
                // Transform 4x4 matrix attribute
                UT_Matrix4T<T> transform;
                transform.identity();
                auto &&get_transform = [&transform,cross_sections_per_vertex,&fix_transformi_for_all_case]
                    (const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const UT_Matrix4T<T>*
                {
                    exint transformi = row;
                    if (cross_sections_per_vertex != 1)
                        fix_transformi_for_all_case(transformi);
                    transform = UT_Matrix4T<T>(transforms->getMatrix3s<T>()[transformi]);
                    transform.setTranslates(transforms->getTranslates<T>()[transformi]);
                    return &transform;
                };
                auto &&transform_and_copy = [](
                    const GA_ROHandleT<UT_Matrix4T<T>> &cross_sectionh, GA_Offset cross_section_offset,
                    const UT_Matrix4T<T> *transform,
                    const GA_RWHandleT<UT_Matrix4T<T>> &outputh, GA_Offset output_offset)
                {
                    UT_Matrix4T<T> value = cross_sectionh.get(cross_section_offset);
                    value *= *transform;
                    outputh.set(output_offset, value);
                };
                auto &&transform_and_interp = [](
                    const GA_ROHandleT<UT_Matrix4T<T>> &cross_sectionh,
                    GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
                    const UT_Matrix4T<T> *transform,
                    const GA_RWHandleT<UT_Matrix4T<T>> &outputh, GA_Offset output_offset)
                {
                    const UT_Matrix4T<T> value0 = cross_sectionh.get(cross_section_offset0);
                    const UT_Matrix4T<T> value1 = cross_sectionh.get(cross_section_offset1);
                    UT_Matrix4T<T> value = SYSlerp(value0, value1, t);
                    value *= *transform;
                    outputh.set(output_offset, value);
                };
                copyCrossSectionAttributeWrapper<UT_Matrix4T<T>, UT_Matrix4T<T>, attrib_owner>(grid,
                    output_attrib, cross_section_attrib, cross_section_input, transforms, grid_info,
                    reverse_cross_sections, swap_row_col,
                    get_transform, transform_and_copy, transform_and_interp);
                return;
            }
        }
    }

    // Non-transforming cases follow
    auto &&get_transform = [](const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const void*
    {
        return nullptr;
    };

    bool is_integer_type = std::is_integral<T>::value;
    if (tuple_size == 1)
    {
        // Copy single-component numeric attribute
        auto &&transform_and_copy = [](
            const GA_ROHandleT<T> &cross_sectionh, GA_Offset cross_section_offset,
            const void *transform,
            const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
        {
            T value = cross_sectionh.get(cross_section_offset);
            outputh.set(output_offset, value);
        };
        if (is_integer_type)
        {
            auto &&transform_and_interp = [](
                const GA_ROHandleT<T> &cross_sectionh,
                GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
                const void *transform,
                const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
            {
                GA_Offset cross_section_offset = (t < 0.5) ? cross_section_offset0 : cross_section_offset1;
                T value = cross_sectionh.get(cross_section_offset);
                outputh.set(output_offset, value);
            };
            copyCrossSectionAttributeWrapper<T, void, attrib_owner>(grid,
                output_attrib, cross_section_attrib, cross_section_input, nullptr, grid_info,
                reverse_cross_sections, swap_row_col,
                get_transform, transform_and_copy, transform_and_interp);
        }
        else
        {
            auto &&transform_and_interp = [](
                const GA_ROHandleT<T> &cross_sectionh,
                GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
                const void *transform,
                const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
            {
                const T value0 = cross_sectionh.get(cross_section_offset0);
                const T value1 = cross_sectionh.get(cross_section_offset1);
                T value = SYSlerp(value0, value1, t);
                outputh.set(output_offset, value);
            };
            copyCrossSectionAttributeWrapper<T, void, attrib_owner>(grid,
                output_attrib, cross_section_attrib, cross_section_input, nullptr, grid_info,
                reverse_cross_sections, swap_row_col,
                get_transform, transform_and_copy, transform_and_interp);
        }
        return;
    }
    if (tuple_size == 2 && !is_integer_type)
    {
        // Copy 2-component numeric attribute
        auto &&transform_and_copy = [](
            const GA_ROHandleT<UT_Vector2T<T>> &cross_sectionh, GA_Offset cross_section_offset,
            const void *transform,
            const GA_RWHandleT<UT_Vector2T<T>> &outputh, GA_Offset output_offset)
        {
            UT_Vector2T<T> value = cross_sectionh.get(cross_section_offset);
            outputh.set(output_offset, value);
        };
        auto &&transform_and_interp = [](
            const GA_ROHandleT<UT_Vector2T<T>> &cross_sectionh,
            GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
            const void *transform,
            const GA_RWHandleT<UT_Vector2T<T>> &outputh, GA_Offset output_offset)
        {
            const UT_Vector2T<T> value0 = cross_sectionh.get(cross_section_offset0);
            const UT_Vector2T<T> value1 = cross_sectionh.get(cross_section_offset1);
            UT_Vector2T<T> value = SYSlerp(value0, value1, t);
            outputh.set(output_offset, value);
        };
        copyCrossSectionAttributeWrapper<UT_Vector2T<T>, void, attrib_owner>(grid,
            output_attrib, cross_section_attrib, cross_section_input, nullptr, grid_info,
            reverse_cross_sections, swap_row_col,
            get_transform, transform_and_copy, transform_and_interp);
        return;
    }
    if (tuple_size == 3 && !is_integer_type)
    {
        // Copy 3-component numeric attribute
        auto &&transform_and_copy = [](
            const GA_ROHandleT<UT_Vector3T<T>> &cross_sectionh, GA_Offset cross_section_offset,
            const void *transform,
            const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
        {
            UT_Vector3T<T> value = cross_sectionh.get(cross_section_offset);
            outputh.set(output_offset, value);
        };
        auto &&transform_and_interp = [](
            const GA_ROHandleT<UT_Vector3T<T>> &cross_sectionh,
            GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
            const void *transform,
            const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
        {
            const UT_Vector3T<T> value0 = cross_sectionh.get(cross_section_offset0);
            const UT_Vector3T<T> value1 = cross_sectionh.get(cross_section_offset1);
            UT_Vector3T<T> value = SYSlerp(value0, value1, t);
            outputh.set(output_offset, value);
        };
        copyCrossSectionAttributeWrapper<UT_Vector3T<T>, void, attrib_owner>(grid,
            output_attrib, cross_section_attrib, cross_section_input, nullptr, grid_info,
            reverse_cross_sections, swap_row_col,
            get_transform, transform_and_copy, transform_and_interp);
        return;
    }

    // Copy arbitrary-component numeric attribute
    auto &&transform_and_copy = [tuple_size](
        const GA_ROHandleT<T> &cross_sectionh, GA_Offset cross_section_offset,
        const void *transform,
        const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
    {
        for (exint component = 0; component < tuple_size; ++component)
        {
            T value = cross_sectionh.get(cross_section_offset, component);
            outputh.set(output_offset, component, value);
        }
    };
    if (is_integer_type)
    {
        auto &&transform_and_interp = [tuple_size](
            const GA_ROHandleT<T> &cross_sectionh,
            GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, double t,
            const void *transform,
            const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
        {
            GA_Offset cross_section_offset = (t < 0.5) ? cross_section_offset0 : cross_section_offset1;
            for (exint component = 0; component < tuple_size; ++component)
            {
                T value = cross_sectionh.get(cross_section_offset, component);
                outputh.set(output_offset, component, value);
            }
        };
        copyCrossSectionAttributeWrapper<T, void, attrib_owner>(grid,
            output_attrib, cross_section_attrib, cross_section_input, nullptr, grid_info,
            reverse_cross_sections, swap_row_col,
            get_transform, transform_and_copy, transform_and_interp);
    }
    else
    {
        auto &&transform_and_interp = [tuple_size](
            const GA_ROHandleT<T> &cross_sectionh,
            GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, double t,
            const void *transform,
            const GA_RWHandleT<T> &outputh, GA_Offset output_offset)
        {
            for (exint component = 0; component < tuple_size; ++component)
            {
                const T value0 = cross_sectionh.get(cross_section_offset0, component);
                const T value1 = cross_sectionh.get(cross_section_offset1, component);
                T value = SYSlerp(value0, value1, t);
                outputh.set(output_offset, component, value);
            }
        };
        copyCrossSectionAttributeWrapper<T, void, attrib_owner>(grid,
            output_attrib, cross_section_attrib, cross_section_input, nullptr, grid_info,
            reverse_cross_sections, swap_row_col,
            get_transform, transform_and_copy, transform_and_interp);
    }
}

template<GA_AttributeOwner attrib_owner>
static void
copyAttribSingleGrid(
    GA_Attribute *output_attrib,
    const GA_Attribute *cross_section_attrib,
    const GEO_Detail *cross_section_input,
    const sop_SweepGrid &grid_info,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const bool reverse_cross_sections,
    const bool swap_row_col)
{
    // Copy non-numeric attribute

    GU_GridT<GA_Offset> grid;
    initGUGrid(grid_info, surface_type, output_points_only, triangular_poles, swap_row_col, grid_info.myStartPtOff, grid);

    // Non-transforming
    auto &&get_transform = [](const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const void*
    {
        return nullptr;
    };

    auto &&transform_and_copy = [](
        const GA_Attribute *cross_section_attrib, GA_Offset cross_section_offset,
        const void *transform,
        GA_Attribute *output_attrib, GA_Offset output_offset)
    {
        output_attrib->copy(output_offset, *cross_section_attrib, cross_section_offset);
    };
    auto &&transform_and_interp = [](
        const GA_Attribute *cross_section_attrib,
        GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, double t,
        const void *transform,
        GA_Attribute *output_attrib, GA_Offset output_offset)
    {
        GA_Offset cross_section_offset = (t < 0.5) ? cross_section_offset0 : cross_section_offset1;
        output_attrib->copy(output_offset, *cross_section_attrib, cross_section_offset);
    };

    UT_ASSERT(attrib_owner == cross_section_attrib->getOwner());
    copyCrossSectionAttributeWrapper2<void, attrib_owner>(grid,
        output_attrib, cross_section_attrib, attrib_owner, cross_section_input, nullptr, grid_info,
        reverse_cross_sections, swap_row_col,
        get_transform, transform_and_copy, transform_and_interp);
}

static const sop_SweepGridTransformWrapper *
gridOffsetTransforms(
    const SOP_SweepHDKCache *const transform_cache,
    sop_SweepGridTransformWrapper &grid_transforms,
    const exint gridi)
{
    if (transform_cache == nullptr)
        return nullptr;

    grid_transforms.init(*transform_cache, gridi);

    return &grid_transforms;
}

template<GA_AttributeOwner attrib_owner>
static void
copyCrossSectionAttrib2(
    GA_Attribute *output_attrib,
    const GA_Attribute *cross_section_attrib,
    const GEO_Detail *cross_section_input,
    const SOP_SweepHDKCache *transform_cache,
    const sop_SweepGrid *grids,
    exint ngrids,
    const exint cross_sections_per_vertex,
    const exint cap_divisions,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const bool reverse_cross_sections,
    const bool swap_row_col)
{
    UT_ASSERT(output_attrib->getOwner() == attrib_owner);
    UT_ASSERT(cross_section_attrib->getOwner() == attrib_owner);

    const exint PARALLEL_THRESHOLD = 2048;
    const bool parallel = (ngrids > 1 &&
        output_attrib->getIndexMap().indexSize() >= PARALLEL_THRESHOLD);
    const UT_BlockedRange<exint> grid_range(0, ngrids);

    GA_ATINumeric *const output_numeric = GA_ATINumeric::cast(output_attrib);
    if (!output_numeric)
    {
        output_attrib->bumpDataId();
        auto&& functor = [&](const UT_BlockedRange<exint>& r)
        {
            for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
            {
                copyAttribSingleGrid<attrib_owner>(
                    output_attrib, cross_section_attrib, cross_section_input,
                    grids[gridi],
                    surface_type, output_points_only, triangular_poles,
                    reverse_cross_sections, swap_row_col);
            }
        };
        if (parallel)
        {
            // Must harden all pages before multi-threading.
            output_attrib->hardenAllPages();
            UTparallelFor(grid_range, functor);
        }
        else
        {
            functor(grid_range);
        }
        return;
    }

    const GA_ATINumeric *const cross_section_numeric = GA_ATINumeric::cast(cross_section_attrib);
    UT_ASSERT(cross_section_numeric);
    if (!cross_section_numeric)
        return;
    const int tuple_size = output_numeric->getTupleSize();
    UT_ASSERT(tuple_size == cross_section_numeric->getTupleSize());
    if (tuple_size != cross_section_numeric->getTupleSize())
        return;

    output_attrib->bumpDataId();

    if (parallel)
    {
        // Must harden all pages before multi-threading.
        output_attrib->hardenAllPages();
    }

    auto&& functor = [&](const UT_BlockedRange<exint>& r)
    {
        const GA_TypeInfo type_info = cross_section_numeric->getTypeInfo();
        const GA_Storage storage_type = output_numeric->getStorage();
        sop_SweepGridTransformWrapper local_grid_transforms;
        if (tuple_size == 3)
        {
            if (type_info == GA_TYPE_POINT)
            {
                if (storage_type == GA_STORE_REAL64)
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal64,GA_TYPE_POINT,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                else
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal32,GA_TYPE_POINT,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                return;
            }
            if (type_info == GA_TYPE_NORMAL)
            {
                if (storage_type == GA_STORE_REAL64)
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal64,GA_TYPE_NORMAL,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                else
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal32,GA_TYPE_NORMAL,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                return;
            }
            if (type_info == GA_TYPE_VECTOR)
            {
                if (storage_type == GA_STORE_REAL64)
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal64,GA_TYPE_VECTOR,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                else
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal32,GA_TYPE_VECTOR,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                return;
            }
        }
        else if (tuple_size == 4)
        {
            if (type_info == GA_TYPE_QUATERNION)
            {
                if (storage_type == GA_STORE_REAL64)
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal64,GA_TYPE_QUATERNION,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                else
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal32,GA_TYPE_QUATERNION,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                return;
            }
        }
        else if (tuple_size == 9 || tuple_size == 16)
        {
            if (type_info == GA_TYPE_TRANSFORM)
            {
                if (storage_type == GA_STORE_REAL64)
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal64,GA_TYPE_TRANSFORM,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                else
                {
                    for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                    {
                        auto grid_transforms = gridOffsetTransforms(transform_cache, local_grid_transforms, gridi);
                        copyFloatSingleGrid<fpreal32,GA_TYPE_TRANSFORM,attrib_owner>(
                            output_numeric, cross_section_numeric, cross_section_input,
                            grid_transforms, grids[gridi], cross_sections_per_vertex, cap_divisions,
                            surface_type, output_points_only, triangular_poles,
                            reverse_cross_sections, swap_row_col);
                    }
                }
                return;
            }
        }

        if (storage_type == GA_STORE_REAL64)
        {
            for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
            {
                copyFloatSingleGrid<fpreal64,GA_TYPE_VOID,attrib_owner>(
                    output_numeric, cross_section_numeric, cross_section_input,
                    nullptr, grids[gridi], cross_sections_per_vertex, cap_divisions,
                    surface_type, output_points_only, triangular_poles,
                    reverse_cross_sections, swap_row_col);
            }
        }
        else if (storage_type == GA_STORE_REAL32 || storage_type == GA_STORE_REAL16)
        {
            for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
            {
                copyFloatSingleGrid<fpreal32,GA_TYPE_VOID,attrib_owner>(
                    output_numeric, cross_section_numeric, cross_section_input,
                    nullptr, grids[gridi], cross_sections_per_vertex, cap_divisions,
                    surface_type, output_points_only, triangular_poles,
                    reverse_cross_sections, swap_row_col);
            }
        }
        else if (storage_type == GA_STORE_INT64)
        {
            for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
            {
                copyIntegerSingleGrid<int64,attrib_owner>(
                    output_numeric, cross_section_numeric, cross_section_input,
                    nullptr, grids[gridi],
                    surface_type, output_points_only, triangular_poles,
                    reverse_cross_sections, swap_row_col);
            }
        }
        else if (storage_type == GA_STORE_INT32 || storage_type == GA_STORE_INT16 || storage_type == GA_STORE_INT8)
        {
            for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
            {
                copyIntegerSingleGrid<int32,attrib_owner>(
                    output_numeric, cross_section_numeric, cross_section_input,
                    nullptr, grids[gridi],
                    surface_type, output_points_only, triangular_poles,
                    reverse_cross_sections, swap_row_col);
            }
        }
    };

    if (parallel)
        UTparallelFor(grid_range, functor);
    else
        functor(grid_range);
}

static void
copyCrossSectionAttrib(
    GA_Attribute *output_attrib,
    const GA_Attribute *cross_section_attrib,
    const GEO_Detail *cross_section_input,
    const SOP_SweepHDKCache *transform_cache,
    const sop_SweepGrid *grids,
    exint ngrids,
    const exint cross_sections_per_vertex,
    const exint cap_divisions,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const bool reverse_cross_sections,
    const bool swap_row_col)
{
    UT_ASSERT(output_attrib->getOwner() == cross_section_attrib->getOwner());

    GA_AttributeOwner owner = output_attrib->getOwner();
    if (owner == GA_ATTRIB_POINT)
    {
        copyCrossSectionAttrib2<GA_ATTRIB_POINT>(
            output_attrib, cross_section_attrib, cross_section_input,
            transform_cache, grids, ngrids, cross_sections_per_vertex, cap_divisions,
            surface_type, output_points_only, triangular_poles,
            reverse_cross_sections, swap_row_col);
    }
    else if (owner == GA_ATTRIB_VERTEX)
    {
        copyCrossSectionAttrib2<GA_ATTRIB_VERTEX>(
            output_attrib, cross_section_attrib, cross_section_input,
            transform_cache, grids, ngrids, cross_sections_per_vertex, cap_divisions,
            surface_type, output_points_only, triangular_poles,
            reverse_cross_sections, swap_row_col);
    }
    else if (owner == GA_ATTRIB_PRIMITIVE)
    {
        copyCrossSectionAttrib2<GA_ATTRIB_PRIMITIVE>(
            output_attrib, cross_section_attrib, cross_section_input,
            transform_cache, grids, ngrids, cross_sections_per_vertex, cap_divisions,
            surface_type, output_points_only, triangular_poles,
            reverse_cross_sections, swap_row_col);
    }
    else if (owner == GA_ATTRIB_DETAIL)
    {
        output_attrib->replace(*cross_section_attrib);
    }
}

template<bool wrap_to_invalid,typename FUNCTOR>
static void
copyVertexCurveAttribWrapper(
    const sop_SweepGrid &grid_info,
    const GU_GridT<GA_Offset> &grid,
    exint num_vertices,
    exint cap_divisions,
    exint cross_sections_per_vertex,
    const bool swap_row_col,
    const FUNCTOR &copy_functor)
{
    const exint curve_nedges = grid_info.myCurveNEdges;
    const exint cross_section_nedges = grid_info.myCrossSectionNEdges;

    const exint cap_divs = (grid_info.myVEndPoles && !grid_info.myHasPolygonCaps) ? cap_divisions : 0;
    exint prev_vtxi = -1;
    exint curve_vtxi;
    exint cap_vertex_count = 0;
    if (grid_info.myHasPolygonCaps)
    {
        if (swap_row_col ? grid.myNoWrapU : grid.myNoWrapV)
        {
            // First row cap
            cap_vertex_count = cross_section_nedges;

            curve_vtxi = 0;
            prev_vtxi = 0;

            for (exint col = 0; col < cap_vertex_count; ++col)
            {
                copy_functor(grid_info.myStartVtxOff + col, 0);
            }
        }
        else
        {
            // First side col cap
            cap_vertex_count = curve_nedges;

            for (exint row = 0; row < cap_vertex_count; ++row)
            {
                copy_functor(grid_info.myStartVtxOff + row, row);
            }
        }
    }
    // Copy to main grid vertices
    const GA_Offset start_vtxoff = grid_info.myStartVtxOff + cap_vertex_count;
    const bool closed_curve = grid_info.myCurveClosed;
    GUiterateGridVertices(grid, [cap_divs, &prev_vtxi, &curve_vtxi, num_vertices,
        start_vtxoff, cross_sections_per_vertex, swap_row_col, closed_curve, &copy_functor]
        (exint vtxnum, exint row, exint col, bool isrowend, bool iscolend, exint primnum, exint primvtxnum)
    {
        exint vtxi = swap_row_col ? col : row;
        vtxi += exint(swap_row_col ? iscolend : isrowend);
        if (vtxi != prev_vtxi)
        {
            curve_vtxi = vtxi - cap_divs;
            if (cross_sections_per_vertex != 1)
                curve_vtxi /= cross_sections_per_vertex;
            if (curve_vtxi < 0)
                curve_vtxi = 0;
            else if (curve_vtxi >= num_vertices)
            {
                if (!closed_curve)
                    curve_vtxi = num_vertices-1;
                else if (wrap_to_invalid)
                    curve_vtxi = -1;
                else
                    curve_vtxi = 0;
            }
            prev_vtxi = vtxi;
        }
        copy_functor(start_vtxoff + vtxnum, curve_vtxi);
    });
    if (grid_info.myHasPolygonCaps)
    {
        // Last cap starts after main grid
        const GA_Offset cap_start_vtxoff = start_vtxoff + grid.myNumVertices;
        if (swap_row_col ? grid.myNoWrapU : grid.myNoWrapV)
        {
            // Last row cap
            curve_vtxi = num_vertices-1;

            for (exint col = 0; col < cap_vertex_count; ++col)
            {
                copy_functor(cap_start_vtxoff + col, curve_vtxi);
            }
        }
        else
        {
            // Last side col cap
            for (exint row = 0; row < cap_vertex_count; ++row)
            {
                copy_functor(cap_start_vtxoff + row, row);
            }
        }
    }
}

template<GA_AttributeOwner attrib_owner,bool wrap_to_invalid=false,typename COPY_FUNCTOR>
static void
copyCurveAttrib2(
    GA_Attribute *output_attrib,
    const GEO_Detail *curve_input,
    const sop_SweepGrid *grids,
    exint ngrids,
    const exint cross_sections_per_vertex,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const exint cap_divisions,
    const bool swap_row_col,
    const COPY_FUNCTOR &copy_functor)
{
    UT_ASSERT(output_attrib->getOwner() == attrib_owner);
    SYS_STATIC_ASSERT(attrib_owner == GA_ATTRIB_POINT || attrib_owner == GA_ATTRIB_VERTEX);

    output_attrib->bumpDataId();

    auto&& functor = [&](const UT_BlockedRange<exint>& r)
    {
        for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
        {
            const sop_SweepGrid &grid_info = grids[gridi];
            GU_GridT<GA_Offset> grid;
            initGUGrid(grid_info, surface_type, output_points_only, triangular_poles, swap_row_col, grid_info.myStartPtOff, grid);

            const GA_OffsetListRef vertices = curve_input->getPrimitiveVertexList(grid_info.myCurvePrimOff);
            if (attrib_owner == GA_ATTRIB_VERTEX)
            {
                copyVertexCurveAttribWrapper<wrap_to_invalid>(grid_info, grid, vertices.size(), cap_divisions, cross_sections_per_vertex, swap_row_col,
                    [&copy_functor,&vertices](GA_Offset output_vtxoff, exint curve_vtxi)
                {
                    GA_Offset curve_vtxoff = (wrap_to_invalid && curve_vtxi < 0) ? GA_INVALID_OFFSET : vertices(curve_vtxi);
                    copy_functor(output_vtxoff, curve_vtxoff);
                });
            }
            else
            {
                UT_ASSERT(attrib_owner == GA_ATTRIB_POINT);
                const exint cap_divs = (grid_info.myVEndPoles && !grid_info.myHasPolygonCaps) ? cap_divisions : 0;
                exint prev_vtxi = -1;
                GA_Offset curve_ptoff;
                GUiterateGridPoints(grid, [cap_divs, &vertices, &prev_vtxi,
                    &curve_ptoff, curve_input, cross_sections_per_vertex, swap_row_col, &copy_functor]
                    (GA_Offset output_ptoff, exint row, exint col)
                {
                    exint vtxi = swap_row_col ? col : row;
                    if (vtxi != prev_vtxi)
                    {
                        exint curve_vtxi = vtxi - cap_divs;
                        if (cross_sections_per_vertex != 1)
                            curve_vtxi /= cross_sections_per_vertex;
                        if (curve_vtxi < 0)
                            curve_vtxi = 0;
                        else if (curve_vtxi >= vertices.size())
                            curve_vtxi = vertices.size()-1;
                        GA_Offset curve_vtxoff = vertices(curve_vtxi);
                        curve_ptoff = curve_input->vertexPoint(curve_vtxoff);
                        prev_vtxi = vtxi;
                    }
                    copy_functor(output_ptoff, curve_ptoff);
                });
            }
        }
    };

    const exint PARALLEL_THRESHOLD = 2048;
    if (ngrids > 1 && output_attrib->getIndexMap().indexSize() >= PARALLEL_THRESHOLD)
    {
        // Must harden all pages before multi-threading.
        output_attrib->hardenAllPages();

        UTparallelFor(UT_BlockedRange<exint>(0, ngrids), functor);
    }
    else
    {
        functor(UT_BlockedRange<exint>(0, ngrids));
    }
}

static void
copyCurveAttrib(
    GA_Attribute *output_attrib,
    const GA_Attribute *curve_attrib,
    const GEO_Detail *curve_input,
    const sop_SweepGrid *grids,
    exint ngrids,
    const exint cross_sections_per_vertex,
    const GEO_SurfaceType surface_type,
    const bool output_points_only,
    const bool triangular_poles,
    const exint cap_divisions,
    const bool swap_row_col)
{
    UT_ASSERT(output_attrib->getOwner() == curve_attrib->getOwner());

    const GA_AttributeOwner owner = output_attrib->getOwner();
    if (owner == GA_ATTRIB_POINT)
    {
        auto &&copy_functor = [output_attrib,curve_attrib](GA_Offset output_off, GA_Offset curve_off)
        {
            output_attrib->copy(output_off, *curve_attrib, curve_off);
        };
        copyCurveAttrib2<GA_ATTRIB_POINT>(
            output_attrib, curve_input,
            grids, ngrids, cross_sections_per_vertex,
            surface_type, output_points_only, triangular_poles, cap_divisions,
            swap_row_col, copy_functor);
    }
    else if (owner == GA_ATTRIB_VERTEX)
    {
        if (!output_points_only)
        {
            auto &&copy_functor = [output_attrib,curve_attrib](GA_Offset output_off, GA_Offset curve_off)
            {
                output_attrib->copy(output_off, *curve_attrib, curve_off);
            };
            copyCurveAttrib2<GA_ATTRIB_VERTEX>(
                output_attrib, curve_input,
                grids, ngrids, cross_sections_per_vertex,
                surface_type, output_points_only, triangular_poles, cap_divisions,
                swap_row_col, copy_functor);
        }
    }
    else if (owner == GA_ATTRIB_PRIMITIVE)
    {
        if (!output_points_only)
        {
            UT_ASSERT(curve_attrib->getOwner() == GA_ATTRIB_PRIMITIVE);

            output_attrib->bumpDataId();

            auto&& functor = [&](const UT_BlockedRange<exint>& r)
            {
                for (exint gridi = r.begin(); gridi < r.end(); ++gridi)
                {
                    const sop_SweepGrid &grid_info = grids[gridi];
                    GU_GridT<GA_Offset> grid;
                    initGUGrid(grid_info, surface_type, output_points_only, triangular_poles, swap_row_col, grid_info.myStartPtOff, grid);

                    // Copy same value to all primitives in grid
                    const GA_Offset startprimoff = grid_info.myStartPrimOff;
                    const GA_Offset endprimoff = startprimoff + grid.myNumPrimitives + (grid_info.myHasPolygonCaps ? 2 : 0);
                    output_attrib->fill(GA_Range(output_attrib->getIndexMap(), startprimoff, endprimoff), *curve_attrib, grid_info.myCurvePrimOff);
                }
            };

            const exint PARALLEL_THRESHOLD = 2048;
            if (ngrids > 1 && output_attrib->getIndexMap().indexSize() >= PARALLEL_THRESHOLD)
            {
                // Must harden all pages before multi-threading.
                output_attrib->hardenAllPages();

                UTparallelFor(UT_BlockedRange<exint>(0, ngrids), functor);
            }
            else
            {
                functor(UT_BlockedRange<exint>(0, ngrids));
            }
        }
    }
    else if (owner == GA_ATTRIB_DETAIL)
    {
        output_attrib->replace(*curve_attrib);
    }
}

enum class UVStyle {
    NORMALIZED,
    ROUNDED,
    FULL
};

// This is for copying a single component from the cross section attribute to the grid.
// NOTE: UVStyle should already be folded into uscale by the caller!
template<typename T,GA_AttributeOwner output_owner>
static void
copyCrossSectionUVSingleGrid(
    GA_ATINumeric *output_attrib,
    const GA_ATINumeric *cross_section_attrib,
    const GA_AttributeOwner cross_section_owner,
    const GEO_Detail *cross_section_input,
    const sop_SweepGrid &grid_info,
    const GU_GridT<GA_Offset> &grid,
    const bool is_cross_section_uv_computed,
    const bool reverse_cross_sections,
    const bool swap_row_col,
    const bool flipu,
    const T uscale,
    const UT_Array<double> *missing_input_us = nullptr)
{
    UT_ASSERT_P((cross_section_attrib != nullptr && cross_section_input != nullptr && cross_section_owner != GA_ATTRIB_INVALID)
        || (cross_section_owner == GA_ATTRIB_INVALID && missing_input_us != nullptr));

    SYS_STATIC_ASSERT(!std::is_integral<T>::value);

    const int tuple_size = output_attrib->getTupleSize();

    // Non-transforming
    auto &&get_transform = [](const sop_SweepGridTransformWrapper *transforms, exint row, const sop_SweepGrid &grid_info) -> const void*
    {
        return nullptr;
    };

    if (cross_section_owner == GA_ATTRIB_INVALID)
    {
        // Single cross section with implicit U value already computed.
        UT_ASSERT(missing_input_us != nullptr);
        UT_ASSERT(output_owner == GA_ATTRIB_VERTEX || output_owner == GA_ATTRIB_POINT);
        if (tuple_size == 2)
        {
            const GA_RWHandleT<UT_Vector2T<T>> outputh(output_attrib);
            UT_ASSERT_P(outputh.isValid());
            auto &&copy_functor = [missing_input_us,&outputh,flipu,swap_row_col,uscale](
                GA_Offset output_offset, exint row, exint col)
            {
                const exint cross_section_vtxi = swap_row_col ? row : col;
                T value = (cross_section_vtxi == missing_input_us->size()) ? T(1.0) : (*missing_input_us)[cross_section_vtxi];
                if (flipu)
                    value = T(1.0)-value;
                UT_Vector2T<T> output_value = outputh.get(output_offset);
                output_value[theUComponent] = uscale*value;
                outputh.set(output_offset, output_value);
            };
            if (output_owner == GA_ATTRIB_VERTEX)
                copyVertexCrossSectionWrapper(grid, grid_info, copy_functor);
            else
                GUiterateGridPoints(grid, copy_functor);
        }
        else if (tuple_size == 3)
        {
            const GA_RWHandleT<UT_Vector3T<T>> outputh(output_attrib);
            UT_ASSERT_P(outputh.isValid());
            auto &&copy_functor = [missing_input_us,&outputh,flipu,swap_row_col,uscale](
                GA_Offset output_offset, exint row, exint col)
            {
                const exint cross_section_vtxi = swap_row_col ? row : col;
                T value = (cross_section_vtxi == missing_input_us->size()) ? T(1.0) : (*missing_input_us)[cross_section_vtxi];
                if (flipu)
                    value = T(1.0)-value;
                UT_Vector3T<T> output_value = outputh.get(output_offset);
                output_value[theUComponent] = uscale*value;
                outputh.set(output_offset, output_value);
            };
            if (output_owner == GA_ATTRIB_VERTEX)
                copyVertexCrossSectionWrapper(grid, grid_info, copy_functor);
            else
                GUiterateGridPoints(grid, copy_functor);
        }
        return;
    }

    if (tuple_size == 2)
    {
        // Copy u component of 2-component numeric attribute
        auto &&transform_and_copy = [flipu,reverse_cross_sections,uscale,is_cross_section_uv_computed](
            const GA_ROHandleT<T> &cross_sectionh, GA_Offset cross_section_offset,
            const void *transform,
            const GA_RWHandleT<UT_Vector2T<T>> &outputh, GA_Offset output_offset)
        {
            T value;
            if (output_owner == GA_ATTRIB_VERTEX && cross_section_offset == GA_INVALID_OFFSET)
                value = reverse_cross_sections ? T(0.0) : T(1.0);
            else
                value = cross_sectionh.get(cross_section_offset);

            if (flipu)
                value = T(1.0)-value;
            if (is_cross_section_uv_computed)
                value *= uscale;
            UT_Vector2T<T> output_value = outputh.get(output_offset);
            output_value[theUComponent] = value;
            outputh.set(output_offset, output_value);
        };
        auto &&transform_and_interp = [flipu,reverse_cross_sections,uscale,is_cross_section_uv_computed](
            const GA_ROHandleT<T> &cross_sectionh,
            GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
            const void *transform,
            const GA_RWHandleT<UT_Vector2T<T>> &outputh, GA_Offset output_offset)
        {
            UT_ASSERT_P(GAisValid(cross_section_offset0));
            const T value0 = cross_sectionh.get(cross_section_offset0);
            // cross_section_offset1 might be invalid here if we have closed, non-unrolled
            // cross sections with different numbers of vertices and we're on the last edge.
            T value1;
            if (output_owner == GA_ATTRIB_VERTEX && cross_section_offset1 == GA_INVALID_OFFSET)
                value1 = reverse_cross_sections ? T(0.0) : T(1.0);
            else
                value1 = cross_sectionh.get(cross_section_offset1);

            T value = SYSlerp(value0, value1, t);
            if (flipu)
                value = T(1.0)-value;
            if (is_cross_section_uv_computed)
                value *= uscale;
            UT_Vector2T<T> output_value = outputh.get(output_offset);
            output_value[theUComponent] = value;
            outputh.set(output_offset, output_value);
        };
        GA_ROHandleT<T> cross_sectionh(cross_section_attrib);
        GA_RWHandleT<UT_Vector2T<T>> outputh(output_attrib);
        // true indicates to specify GA_INVALID_OFFSET, instead of the first vertex,
        // when wrapping, so that 1.0 can be written.
        constexpr bool wrap_to_invalid = output_owner == GA_ATTRIB_VERTEX;
        copyCrossSectionAttributeWrapper2<void, output_owner, wrap_to_invalid>(grid,
            outputh, cross_sectionh, cross_section_owner, cross_section_input, nullptr, grid_info,
            reverse_cross_sections, swap_row_col,
            get_transform, transform_and_copy, transform_and_interp);
        return;
    }
    if (tuple_size == 3)
    {
        // Copy u component of 3-component numeric attribute
        auto &&transform_and_copy = [flipu,reverse_cross_sections,uscale,is_cross_section_uv_computed](
            const GA_ROHandleT<T> &cross_sectionh, GA_Offset cross_section_offset,
            const void *transform,
            const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
        {
            T value;
            if (output_owner == GA_ATTRIB_VERTEX && cross_section_offset == GA_INVALID_OFFSET)
                value = reverse_cross_sections ? T(0.0) : T(1.0);
            else
                value = cross_sectionh.get(cross_section_offset);

            if (flipu)
                value = T(1.0)-value;
            if (is_cross_section_uv_computed)
                value *= uscale;
            UT_Vector3T<T> output_value = outputh.get(output_offset);
            output_value[theUComponent] = value;
            outputh.set(output_offset, output_value);
        };
        auto &&transform_and_interp = [flipu,reverse_cross_sections,uscale,is_cross_section_uv_computed](
            const GA_ROHandleT<T> &cross_sectionh,
            GA_Offset cross_section_offset0, GA_Offset cross_section_offset1, T t,
            const void *transform,
            const GA_RWHandleT<UT_Vector3T<T>> &outputh, GA_Offset output_offset)
        {
            UT_ASSERT_P(GAisValid(cross_section_offset0));
            const T value0 = cross_sectionh.get(cross_section_offset0);
            // cross_section_offset1 might be invalid here if we have closed, non-unrolled
            // cross sections with different numbers of vertices and we're on the last edge.
            T value1;
            if (output_owner == GA_ATTRIB_VERTEX && cross_section_offset1 == GA_INVALID_OFFSET)
                value1 = reverse_cross_sections ? T(0.0) : T(1.0);
            else
                value1 = cross_sectionh.get(cross_section_offset1);

            T value = SYSlerp(value0, value1, t);
            if (flipu)
                value = T(1.0)-value;
            if (is_cross_section_uv_computed)
                value *= uscale;
            UT_Vector3T<T> output_value = outputh.get(output_offset);
            output_value[theUComponent] = value;
            outputh.set(output_offset, output_value);
        };
        GA_ROHandleT<T> cross_sectionh(cross_section_attrib);
        GA_RWHandleT<UT_Vector3T<T>> outputh(output_attrib);
        // true indicates to specify GA_INVALID_OFFSET, instead of the first vertex,
        // when wrapping, so that 1.0 can be written.
        constexpr bool wrap_to_invalid = output_owner == GA_ATTRIB_VERTEX;
        copyCrossSectionAttributeWrapper2<void, output_owner, wrap_to_invalid>(grid,
            outputh, cross_sectionh, cross_section_owner, cross_section_input, nullptr, grid_info,
            reverse_cross_sections, swap_row_col,
            get_transform, transform_and_copy, transform_and_interp);
        return;
    }
}

template<typename T>
static UT_Vector3D crossSectionCenter(
    bool swap_row_col,
    const GA_ROHandleT<UT_Vector3T<T>> &pos,
    const GU_GridT<GA_Offset> &grid,
    const exint cross_section_nedges,
    const exint curve_row)
{
    UT_Vector3D sum(0,0,0);
    for (exint cross_section_vtxi = 0; cross_section_vtxi < cross_section_nedges; ++cross_section_vtxi)
    {
        exint row = curve_row;;
        exint col = cross_section_vtxi;
        if (swap_row_col)
            UTswap(row, col);
        const UT_Vector3T<T> curr_pos = pos.get(grid.getPoint(row, col));
        sum += curr_pos;
    }

    return sum / cross_section_nedges;
}

// Computes the total "length" of a single cross section in
// the given grid.  If dir0 is null, positions are treated as is.
// If dir0 is non-null and dir1 is null, dir0 will be projected
// out of the positions before length is computed.
// If dir0 and dir1 are both non-null, the average of the two projections
// will be computed.  Each must be normalized if non-null.
template<typename T>
static double crossSectionLength(
    bool swap_row_col,
    const GA_ROHandleT<UT_Vector3T<T>> &pos,
    const GU_GridT<GA_Offset> &grid,
    const exint cross_section_nedges,
    const exint curve_row,
    const UT_Vector3T<T> *dir0,
    const UT_Vector3T<T> *dir1)
{
    double cross_section_length = 0;
    exint row = curve_row;
    exint col = 0;
    if (swap_row_col)
        UTswap(row, col);
    UT_Vector3T<T> prevpos = pos.get(grid.getPoint(row, col));
    UT_Vector3T<T> prevpos0;
    UT_Vector3T<T> prevpos1;
    if (dir0 != nullptr)
    {
        T d = prevpos.dot(*dir0);
        prevpos0 = prevpos - d*(*dir0);
        if (dir1 != nullptr)
        {
            d = prevpos.dot(*dir1);
            prevpos1 = prevpos - d*(*dir1);
        }
    }
    for (exint cross_section_vtxi = 0; cross_section_vtxi < cross_section_nedges; ++cross_section_vtxi)
    {
        exint row = curve_row;
        exint col = cross_section_vtxi+1;
        if (swap_row_col)
            UTswap(row, col);
        const UT_Vector3T<T> nextpos = pos.get(grid.getPoint(row, col));
        UT_Vector3T<T> nextpos0;
        UT_Vector3T<T> nextpos1;
        if (dir0 != nullptr)
        {
            T d = nextpos.dot(*dir0);
            nextpos0 = nextpos - d*(*dir0);
            T dist0 = prevpos0.distance(nextpos0);
            if (dir1 != nullptr)
            {
                d = nextpos.dot(*dir1);
                nextpos1 = nextpos - d*(*dir1);

                cross_section_length += 0.5f*(dist0 + prevpos1.distance(nextpos1));
            }
            else
            {
                cross_section_length += dist0;
            }
        }
        else
        {
            cross_section_length += prevpos.distance(nextpos);
        }
        prevpos = nextpos;
        if (dir0 != nullptr)
        {
            prevpos0 = nextpos0;
            if (dir1 != nullptr)
                prevpos1 = nextpos1;
        }
    }
    return cross_section_length;
}

template<typename T, typename FUNCTOR>
static void iterateCurveEdgeLengths(
    const exint curve_nedges,
    const bool use_mesh_edge_lengths,

    const exint cross_section_npts,
    const bool swap_row_col,
    const GA_ROHandleT<UT_Vector3T<T>> &pos,
    const GU_GridT<GA_Offset> &grid,

    const sop_SweepGrid &grid_info,
    const exint cap_divisions,
    const GA_ROHandleT<UT_Vector3T<T>> &curve_pos,
    const GEO_Detail *curve_input,
    const GA_OffsetListRef &curve_vertices,

    FUNCTOR&& functor)
{
    for (exint curve_vtxi = 0; curve_vtxi < curve_nedges; ++curve_vtxi)
    {
        double length_sum = 0;
        exint length_sum_count;
        if (use_mesh_edge_lengths)
        {
            length_sum_count = cross_section_npts;
            for (exint cross_section_vtxi = 0; cross_section_vtxi < cross_section_npts; ++cross_section_vtxi)
            {
                exint col0 = swap_row_col ? curve_vtxi : cross_section_vtxi;
                exint col1 = swap_row_col ? curve_vtxi+1 : cross_section_vtxi;
                exint row0 = swap_row_col ? cross_section_vtxi : curve_vtxi;
                exint row1 = swap_row_col ? cross_section_vtxi : curve_vtxi+1;
                const UT_Vector3T<T> p0 = pos.get(grid.getPoint(row0, col0));
                const UT_Vector3T<T> p1 = pos.get(grid.getPoint(row1, col1));
                length_sum += p0.distance(p1);
            }
        }
        else
        {
            length_sum_count = 1;
            exint orig_curve_vtxi = curve_vtxi;
            if (grid_info.myVEndPoles)
            {
                // Caps all correspond with the curve end positions
                orig_curve_vtxi -= cap_divisions;
                orig_curve_vtxi = SYSclamp(orig_curve_vtxi, GA_Size(0), curve_vertices.size()-1);
            }
            const UT_Vector3T<T> p0 = curve_pos.get(curve_input->vertexPoint(curve_vertices(orig_curve_vtxi)));
            exint orig_curve_vtxi1 = (curve_vertices.getExtraFlag() && curve_vtxi+1 == curve_nedges) ? 0 : curve_vtxi+1;
            if (grid_info.myVEndPoles)
            {
                // Same shift and clamping as with the previous vertex.
                // This can end up with both at the same vertex, so a length of zero for this edge.
                orig_curve_vtxi1 -= cap_divisions;
                orig_curve_vtxi1 = SYSclamp(orig_curve_vtxi1, GA_Size(0), curve_vertices.size()-1);
            }
            const UT_Vector3T<T> p1 = curve_pos.get(curve_input->vertexPoint(curve_vertices(orig_curve_vtxi1)));
            length_sum = p0.distance(p1);
        }

        functor(curve_vtxi, length_sum, length_sum_count);
    }
}

// NOTE: pos is double-precision to match computeGridUVScales
template<GA_AttributeOwner output_owner, typename T>
static void
generateLengthWeightedV(
    const sop_SweepGrid &grid_info,
    const GU_GridT<GA_Offset> &grid,
    const exint cross_sections_per_vertex,
    const GA_RWHandleT<T> &outputh,
    const GA_ROHandleV3D &pos,
    UVStyle ustyle,
    UVStyle vstyle,
    bool scalevasu_usingmax,
    double vscale,
    double orig_vscale,
    bool swap_row_col,
    bool use_mesh_edge_lengths,
    const GEO_Detail *curve_input)
{
    //const exint nedgerows = grid.myNumEdgeRows;
    //const exint nedgecols = grid.myNumEdgeCols;
    const exint curve_nedges = grid_info.myCurveNEdges;
    const exint cross_section_nedges = grid_info.myCrossSectionNEdges;

    GA_OffsetListRef curve_vertices;
    // NOTE: curve_pos is double-precision to match computeGridUVScales
    GA_ROHandleV3D curve_pos;
    exint cap_divisions = 0;
    if (curve_input != nullptr)
    {
        curve_vertices = curve_input->getPrimitiveVertexList(grid_info.myCurvePrimOff);
        if (grid_info.myVEndPoles)
        {
            UT_ASSERT_MSG(!curve_vertices.getExtraFlag(), "Curve should be open, not closed");
            exint orig_curve_nedges = curve_vertices.size() - 1;
            cap_divisions = (grid_info.myCurveNEdges - orig_curve_nedges)/2;
            UT_ASSERT(cap_divisions >= 1);
        }
        curve_pos.bind(curve_input->getP());
    }

    bool norm_u_unnorm_v = (ustyle == UVStyle::NORMALIZED && vstyle != UVStyle::NORMALIZED);
    bool special_case_u_division = (!scalevasu_usingmax && norm_u_unnorm_v);
    //bool need_max_cross_section_length = (scalevasu_usingmax && norm_u_unnorm_v);

    UT_Vector3D prevPos;
    bool prevPosValid = false;
    UT_Vector3D currPos;
    bool currPosValid = false;
    UT_Vector3D nextPos;
    UT_Vector3D dir0;
    UT_Vector3D dir1;
    double length0 = 0;
    double length1 = 0;
    UT_Vector3D *pdir0 = nullptr;
    UT_Vector3D *pdir1 = nullptr;
    double prev_cross_section_length = 0;
    if (special_case_u_division)
    {
        if (curve_input != nullptr)
        {
            UT_ASSERT_P(curve_pos.isValid());
            UT_ASSERT(curve_vertices.size() > 0);
            if (curve_vertices.size() >= 2)
            {
                currPos = curve_pos.get(curve_input->vertexPoint(curve_vertices[0]));
                nextPos = curve_pos.get(curve_input->vertexPoint(curve_vertices[1]));
                currPosValid = true;
                if (grid_info.myCurveClosed)
                {
                    // Closed grid in curve direction, possibly open curve with shared point (unrolled)
                    bool unrolled = !curve_vertices.getExtraFlag();
                    exint last_vtxi = curve_vertices.size() - (unrolled ? 2 : 1);
                    prevPos = curve_pos.get(curve_input->vertexPoint(curve_vertices[last_vtxi]));
                    prevPosValid = true;
                }
            }
        }
        else if (curve_nedges >= 1 + (grid_info.myVEndPoles ? 2*cap_divisions : 0))
        {
            // If there's no curve, we use the cross section centers to
            // determine the implicit curve egde directions.
            exint start = grid_info.myVEndPoles ? cap_divisions : 0;
            currPos = crossSectionCenter(swap_row_col, pos, grid, cross_section_nedges, start);
            nextPos = crossSectionCenter(swap_row_col, pos, grid, cross_section_nedges, start+1);
            currPosValid = true;
            if (grid_info.myCurveClosed)
            {
                prevPos = crossSectionCenter(swap_row_col, pos, grid, cross_section_nedges, curve_nedges-1);
                prevPosValid = true;
            }
        }

        if (prevPosValid)
        {
            dir0 = (currPos - prevPos);
            dir1 = (nextPos - currPos);
            length0 = dir0.normalize();
            length1 = dir1.normalize();
            if (length0 != 0 && length1 != 0)
            {
                pdir0 = &dir0;
                pdir1 = &dir1;
            }
            else if (length0 != 0 || length1 != 0)
                pdir0 = (length0 != 0) ? &dir0 : &dir1;
        }
        else if (currPosValid)
        {
            dir1 = (nextPos - currPos);
            length1 = dir1.normalize();
            if (length1 != 0)
                pdir0 = &dir1;
        }

        prev_cross_section_length = crossSectionLength(swap_row_col, pos, grid, cross_section_nedges, 0, pdir0, pdir1);
        if (currPosValid)
        {
            currPos = nextPos;
            dir0 = dir1;
            length0 = length1;
        }
    }
#if 0
    double max_cross_section_length = 0;
    if (need_max_cross_section_length)
    {
        for (exint curve_vtxi = 0; curve_vtxi <= curve_nedges; ++curve_vtxi)
        {
            double cross_section_length = crossSectionLength(swap_row_col, pos, grid, cross_section_nedges, curve_vtxi, dir0, dir1);
            max_cross_section_length = SYSmax(cross_section_length, max_cross_section_length);
        }
    }
#endif

    UT_SmallArray<double> length_sums;
    length_sums.setSizeNoInit(curve_nedges+1);
    length_sums[0] = 0;
    double total_length_sum = 0;
    exint curve_npts = curve_nedges + !grid_info.myCurveClosed;
    exint cross_section_npts = cross_section_nedges + !grid_info.myCrossSectionClosed;
    iterateCurveEdgeLengths(
        curve_nedges,
        use_mesh_edge_lengths,
        cross_section_npts,
        swap_row_col,
        pos,
        grid,
        grid_info,
        cap_divisions,
        curve_pos,
        curve_input,
        curve_vertices,
        [&](exint curve_vtxi, double length_sum, exint length_sum_count)
    {
        if (special_case_u_division)
        {
            bool nextPosValid = false;
            // FIXME: Double-check these bounds!!!
            if (!grid_info.myVEndPoles || (curve_vtxi >= cap_divisions && curve_vtxi < curve_npts-cap_divisions))
            {
                nextPosValid = true;
                if (cross_section_nedges >= 1)
                {
                    exint nextPosVtxi = curve_vtxi+2;
                    exint threshold = curve_npts;
                    if (grid_info.myVEndPoles)
                    {
                        nextPosVtxi -= cap_divisions;
                        threshold -= 2*cap_divisions;
                    }
                    if (nextPosVtxi >= threshold)
                    {
                        if (grid_info.myCurveClosed)
                            nextPosVtxi -= curve_npts;
                        else
                            nextPosValid = false;
                    }
                    if (nextPosValid)
                    {
                        if (curve_input != nullptr)
                        {
                            UT_ASSERT_P(curve_pos.isValid());
                            exint next_curve_vtxi = nextPosVtxi;
                            if (cross_sections_per_vertex != 1)
                                next_curve_vtxi /= cross_sections_per_vertex;
                            if (next_curve_vtxi < 0)
                                next_curve_vtxi = 0;
                            else if (next_curve_vtxi >= curve_vertices.size())
                                next_curve_vtxi = curve_vertices.size()-1;
                            GA_Offset curve_vtxoff = curve_vertices[next_curve_vtxi];
                            GA_Offset curve_ptoff = curve_input->vertexPoint(curve_vtxoff);
                            nextPos = curve_pos.get(curve_ptoff);
                        }
                        else
                        {
                            nextPos = crossSectionCenter(swap_row_col, pos, grid, cross_section_nedges, nextPosVtxi);
                        }
                    }
                }
                pdir0 = nullptr;
                pdir1 = nullptr;
                if (nextPosValid)
                {
                    dir1 = (nextPos - currPos);
                    length1 = dir1.normalize();
                    if (length0 != 0 && length1 != 0)
                    {
                        pdir0 = &dir0;
                        pdir1 = &dir1;
                    }
                    else if (length0 != 0 || length1 != 0)
                        pdir0 = (length0 != 0) ? &dir0 : &dir1;
                }
                else if (length0 != 0)
                {
                    pdir0 = &dir0;
                }
            }
            double next_cross_section_length = crossSectionLength(swap_row_col, pos, grid, cross_section_nedges, curve_vtxi+1, pdir0, pdir1);
            if (nextPosValid)
            {
                currPos = nextPos;
                dir0 = dir1;
                length0 = length1;
            }
            // Use adjacent cross section lengths
            double curr_cross_section_length_avg = 0.5*(prev_cross_section_length + next_cross_section_length);
            if (curr_cross_section_length_avg == 0)
                length_sum = 0;
            else
            {
                // Also normalize length_sum to an average at the same time
                length_sum /= (length_sum_count*curr_cross_section_length_avg);
            }

            prev_cross_section_length = next_cross_section_length;
        }
        else
        {
            // Normalize length_sum to an average
            length_sum /= length_sum_count;
        }

        total_length_sum += length_sum;
        length_sums[curve_vtxi+1] = vscale*total_length_sum;
    });

    UT_ASSERT_MSG(total_length_sum != 0 || (vstyle !=