GU_GridImpl.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:     GU_GridImpl.h (GU Library, C++)
 *
 * COMMENTS: Definitions of GU_Grid-related functions
 */

#pragma once

#include "GU_Grid.h"
#include <GEO/GEO_SurfaceType.h>
#include <UT/UT_Assert.h>
#include <SYS/SYS_Types.h>

/// This calls functor for each point in grid, as:
/// functor(point, row, col)
///
/// Consecutive repeated points in a row are skipped,
/// as well as points at the beginning and end of a wrap.
///
/// Unlike the primitive and vertex iteration functions,
/// the points passed to the functor are not in ascending order,
/// they are the points in the grid.
template<typename INT_TYPE,typename FUNCTOR>
void GUiterateGridPoints(const GU_GridT<INT_TYPE> &grid, FUNCTOR &&functor)
{
    const exint nedgerows = grid.myNumEdgeRows;
    const exint nedgecols = grid.myNumEdgeCols;

    if (nedgerows < 0 || nedgecols < 0)
        return;

    // NOTE: This -1 will never be used, but is here just in case.
    INT_TYPE prev_pt = INT_TYPE(-1);

    for (exint row = 0; row < nedgerows; ++row)
    {
        for (exint col = 0; col < nedgecols; ++col)
        {
            INT_TYPE point = grid.getPoint(row, col);
            if (col == 0 || point != prev_pt)
            {
                functor(point, row, col);
                prev_pt = point;
            }
        }
        INT_TYPE point = grid.getPoint(row, nedgecols);
        if (nedgecols == 0 || (!grid.doesRowWrap(row) && point != prev_pt))
        {
            functor(point, row, nedgecols);
            prev_pt = point;
        }
    }
    for (exint col = 0; col < nedgecols; ++col)
    {
        INT_TYPE point = grid.getPoint(nedgerows, col);
        if (nedgerows == 0 || (!grid.doesColWrap(col) && (col == 0 || point != prev_pt)))
        {
            functor(point, nedgerows, col);
            prev_pt = point;
        }
    }
    INT_TYPE point = grid.getPoint(nedgerows, nedgecols);
    if ((nedgecols == 0 || !grid.doesRowWrap(nedgerows)) && (nedgerows == 0 || !grid.doesColWrap(nedgecols)) && point != prev_pt)
    {
        functor(point, nedgerows, nedgecols);
        prev_pt = point;
    }
}

/// This calls functor for each primitive in grid, as:
/// functor(primnum, row, col, primvtxcount, closed)
template<typename INT_TYPE,typename FUNCTOR>
void GUiterateGridPrimitives(const GU_GridT<INT_TYPE> &grid, FUNCTOR &&functor)
{
    using PrimitiveType = typename GU_GridT<INT_TYPE>::PrimitiveType;
    if (grid.myPrimitiveType == PrimitiveType::POINTS)
        return;

    const GEO_SurfaceType surface_type = grid.mySurfaceType;
    const bool rows_and_cols = (surface_type == GEO_PATCH_ROWCOL);
    const exint nedgerows = grid.myNumEdgeRows;
    const exint nedgecols = grid.myNumEdgeCols;

    if (nedgerows < 0 || nedgecols < 0)
        return;

    exint primnum = 0;

    if (grid.isInvalidTPSurf())
        return;

    if (grid.myPrimitiveType != PrimitiveType::POLYGON)
    {
        // Only one primitive
        // FIXME: Support myCurvesIfBasisRowCol!
        functor(primnum, 0, 0, grid.myNumVertices, false);
        return;
    }

    // Get the special cases out of the way so that it's easier later
    if (nedgerows == 0)
    {
        // Single row
        if (surface_type == GEO_PATCH_ROWS || rows_and_cols)
        {
            exint nvertices = 1; // 1 vertex if both zero, regardless of wrap or unroll.
            bool closed = false;
            if (nedgecols > 0)
            {
                closed = (grid.doesRowWrap(0) && !grid.myUnrollCurves);
                nvertices = nedgecols + exint(!closed);
            }
            functor(primnum, 0, 0, nvertices, closed);
            ++primnum;

            if (!rows_and_cols)
                return;
        }
        if (surface_type == GEO_PATCH_COLS || rows_and_cols)
        {
            exint npoints = 1; // 1 point if both zero, regardless of wrap.
            if (nedgecols > 0)
            {
                bool closed_curve = grid.doesRowWrap(0);
                npoints = nedgecols + exint(!closed_curve);
            }
            for (exint col = 0; col < npoints; ++col)
            {
                functor(primnum, 0, col, 1, false);
                ++primnum;
            }
        }
        // Only rows, cols, and rowcol have vertices when a single row.
        return;
    }
    if (nedgecols == 0)
    {
        // Single column (and multiple rows, since nedgerows==0 has already returned)
        if (surface_type == GEO_PATCH_ROWS || rows_and_cols)
        {
            bool closed_curve = grid.doesColWrap(0);
            exint npoints = nedgerows + exint(!closed_curve);

            for (exint row = 0; row < npoints; ++row)
            {
                functor(primnum, row, 0, 1, false);
                ++primnum;
            }

            if (!rows_and_cols)
                return;
        }
        if (surface_type == GEO_PATCH_COLS || rows_and_cols)
        {
            bool closed = (grid.doesColWrap(0) && !grid.myUnrollCurves);
            exint nvertices = nedgerows + exint(!closed);
            functor(primnum, 0, 0, nvertices, closed);
            ++primnum;
        }
        // Only rows, cols, and rowcol have vertices when a single row.
        return;
    }

    // Main cases; note that nedgerows and nedgecols are both at least 1.

    if (surface_type == GEO_PATCH_ROWS || rows_and_cols)
    {
        bool closed = (grid.myAllWrapU && !grid.myUnrollCurves);
        exint nvertices = nedgecols + exint(!closed);
        bool different_nvertices = (!grid.myAllWrapU && !grid.myNoWrapU && !grid.myUnrollCurves);

        exint first_row = (grid.myNoWrapV && !grid.myFirstRowIfNotWrapped);
        for (exint row = first_row; row < nedgerows; ++row, ++primnum)
        {
            if (different_nvertices)
            {
                closed = grid.doesRowWrap(row);
                nvertices = nedgecols + exint(!closed);
            }
            functor(primnum, row, 0, nvertices, closed);
        }

        if (!grid.myAllWrapV && grid.myLastRowIfNotWrapped)
        {
            if (grid.myNoWrapV)
            {
                if (different_nvertices)
                {
                    closed = grid.doesRowWrap(nedgerows);
                    nvertices = nedgecols + exint(!closed);
                }
                functor(primnum, nedgerows, 0, nvertices, closed);
                ++primnum;
            }
            else
            {
                exint primvtx = 0;
                bool col_wraps = grid.doesColWrap(0);
                bool next_col_wraps;
                exint primstartcol;
                for (exint col = 0; col < nedgecols; ++col, col_wraps = next_col_wraps)
                {
                    next_col_wraps = grid.doesColWrap(col+1);
                    bool currently_in_a_curve = (primvtx != 0);
                    if (!currently_in_a_curve)
                    {
                        if (col_wraps && next_col_wraps)
                        {
                            // If current point and next point are wrapping v,
                            // and we're not currently in a curve, skip.
                            // O=======(O)=======O
                            continue;
                        }

                        // (O)------O           //
                        // (O)------O           //
                        //     or               //
                        // (O)-----\            //
                        // (O)------O           //
                        //     or               //
                        //            /------O  //
                        // O=======(O)-------O  //
                        primstartcol = col;
                        primvtx = 1;
                    }
                    else if (col_wraps && next_col_wraps)
                    {
                        // O------\             //
                        // O-------(O)=======O  //
                        // Done a curve, so call the functor.
                        functor(primnum, nedgerows, primstartcol, col+1-primstartcol, false);
                        ++primnum;
                        primvtx = 0;
                    }
                    else
                    {
                        // O------\   /------O  //
                        // O-------(O)-------O  //
                        //     or               //
                        // O-------(O)-------O  //
                        // O--------O--------O  //
                        //     or               //
                        // O-------(O)------\   //
                        // O--------O--------O  //
                        // Already in a curve, so no need to call the functor.
                        ++primvtx;
                    }
                }
                if ((!grid.doesRowWrap(nedgerows) || grid.myUnrollCurves) && (primvtx != 0))
                {
                    // O-------(O)  //
                    // O-------(O)  //
                    //     or       //
                    // O------\     //
                    // O-------(O)  //
                    //     or       //
                    //  /------(O)  //
                    // O-------(O)  //
                    // Done a curve, so call the functor.
                    functor(primnum, nedgerows, primstartcol, nedgecols+1-primstartcol, false);
                    ++primnum;
                    primvtx = 0;
                }
            }
        }

        if (!rows_and_cols)
            return;
    }
    if (surface_type == GEO_PATCH_COLS || rows_and_cols)
    {
        // Just like the rows case, but with rows and cols (mostly) swapped
        bool closed = (grid.myAllWrapV && !grid.myUnrollCurves);
        exint nvertices = nedgerows + exint(!closed);
        bool different_nvertices = (!grid.myAllWrapV && !grid.myNoWrapV && !grid.myUnrollCurves);

        exint first_col = (grid.myNoWrapU && !grid.myFirstColIfNotWrapped);
        for (exint col = first_col; col < nedgecols; ++col, ++primnum)
        {
            if (different_nvertices)
            {
                closed = grid.doesColWrap(col);
                nvertices = nedgerows + exint(!closed);
            }
            functor(primnum, 0, col, nvertices, closed);
        }

        if (!grid.myAllWrapU && grid.myLastColIfNotWrapped)
        {
            if (grid.myNoWrapU)
            {
                if (different_nvertices)
                {
                    closed = grid.doesColWrap(nedgecols);
                    nvertices = nedgerows + exint(!closed);
                }
                functor(primnum, 0, nedgecols, nvertices, closed);
                ++primnum;
            }
            else
            {
                exint primvtx = 0;
                bool row_wraps = grid.doesRowWrap(0);
                bool next_row_wraps;
                exint primstartrow;
                for (exint row = 0; row < nedgerows; ++row, row_wraps = next_row_wraps)
                {
                    next_row_wraps = grid.doesRowWrap(row+1);
                    bool currently_in_a_curve = (primvtx != 0);
                    if (!currently_in_a_curve)
                    {
                        if (row_wraps && next_row_wraps)
                        {
                            // If current point and next point are wrapping u,
                            // and we're not currently in a curve, skip.
                            // O=======(O)=======O
                            continue;
                        }

                        // (O)------O           //
                        // (O)------O           //
                        //     or               //
                        // (O)-----\            //
                        // (O)------O           //
                        //     or               //
                        //            /------O  //
                        // O=======(O)-------O  //
                        primstartrow = row;
                        primvtx = 1;
                    }
                    else if (row_wraps && next_row_wraps)
                    {
                        // O------\             //
                        // O-------(O)=======O  //
                        // Done a curve, so call the functor.
                        functor(primnum, primstartrow, nedgecols, row+1-primstartrow, false);
                        ++primnum;
                        primvtx = 0;
                    }
                    else
                    {
                        // O------\   /------O  //
                        // O-------(O)-------O  //
                        //     or               //
                        // O-------(O)-------O  //
                        // O--------O--------O  //
                        //     or               //
                        // O-------(O)------\   //
                        // O--------O--------O  //
                        // Already in a curve, so no need to call the functor.
                        ++primvtx;
                    }
                }
                if ((!grid.doesColWrap(nedgecols) || grid.myUnrollCurves) && (primvtx != 0))
                {
                    // O-------(O)  //
                    // O-------(O)  //
                    //     or       //
                    // O------\     //
                    // O-------(O)  //
                    //     or       //
                    //  /------(O)  //
                    // O-------(O)  //
                    // Done a curve, so call the functor.
                    functor(primnum, primstartrow, nedgecols, nedgerows+1-primstartrow, false);
                    ++primnum;
                    primvtx = 0;
                }
            }
        }
        return;
    }

    UT_ASSERT_MSG(nedgerows >= 1 && nedgecols >= 1, "Caller should have switched quads to rows or cols");

    if (!grid.myTriangularPoles)
    {
        if (surface_type == GEO_PATCH_QUADS)
        {
            // All quads: simple.
            for (exint row = 0, primnum = 0; row < nedgerows; ++row)
            {
                for (exint col = 0; col < nedgecols; ++col, ++primnum)
                {
                    functor(primnum, row, col, 4, true);
                }
            }
            return;
        }

        // All tris in the form of quads: simple.
        for (exint row = 0, primnum = 0; row < nedgerows; ++row)
        {
            for (exint col = 0; col < nedgecols; ++col, primnum+=2)
            {
                functor(primnum,   row, col, 3, true);
                functor(primnum+1, row, col, 3, true);
            }
        }
        return;
    }

    // grid.myTriangularPoles is true, which means that any
    // adjacent duplicate points on the boundary will result in triangles,
    // instead of quads.  The big caveat is that if there's only one edge row
    // or only one edge column, things get messy.  The smaller caveat is that if
    // the 3 points of a corner are all the same point, there'd be a degenerate
    // triangle that should probably be removed, so we will.  To deal with
    // both at the same time, we just deal with all boundary quads the same way.

    auto &&boundary_quad = [&grid,surface_type,&functor](exint row, exint col, exint &primnum)
    {
        // Single "quad", but removing degeneracies.

        INT_TYPE points[4];
        points[0] = grid.getPoint(row,   col  );
        points[1] = grid.getPoint(row,   col+1);
        points[2] = grid.getPoint(row+1, col  );
        points[3] = grid.getPoint(row+1, col+1);

        // If the diagonally opposite points are the same, degenerate.
        if (points[0] == points[2] || points[1] == points[3])
            return;

        const bool row0_equal = (points[0] == points[1]);
        const bool row1_equal = (points[2] == points[3]);
        const bool col0_equal = (points[0] == points[2]);
        const bool col1_equal = (points[1] == points[3]);
        // Both ends equal, so degenerate.
        if ((row0_equal && row1_equal) || (col0_equal && col1_equal))
            return;

        if (!row0_equal && !row1_equal && !col0_equal && !col1_equal)
        {
            // Just a quad
            if (surface_type == GEO_PATCH_QUADS)
            {
                functor(primnum, row, col, 4, true);
                ++primnum;
            }
            else
            {
                functor(primnum,   row, col, 3, true);
                functor(primnum+1, row, col, 3, true);
                primnum += 2;
            }
            return;
        }

        // Exactly one adjacent equal pair, so a triangle
        functor(primnum, row, col, 3, true);
        ++primnum;
    };

    exint row = 0;
    for (exint col = 0; col < nedgecols; ++col)
    {
        boundary_quad(row, col, primnum);
    }
    for (row = 1; row < nedgerows-1; ++row)
    {
        exint col = 0;
        boundary_quad(row, col, primnum);

        // Interior quads (tris) as normal, ignoring any potential degeneracy.
        if (surface_type == GEO_PATCH_QUADS)
        {
            for (col = 1; col < nedgecols-1; ++col, ++primnum)
            {
                functor(primnum, row, col, 4, true);
            }
        }
        else
        {
            for (col = 1; col < nedgecols-1; ++col, primnum+=2)
            {
                functor(primnum,   row, col, 3, true);
                functor(primnum+1, row, col, 3, true);
            }
        }

        boundary_quad(row, col, primnum);
    }
    for (exint col = 0; col < nedgecols; ++col)
    {
        boundary_quad(row, col, primnum);
    }
}

/// This calls functor for each vertex in grid, as:
/// functor(vtxnum, row, col, isrowend, iscolend, primnum, primvtxnum)
template<typename INT_TYPE,typename FUNCTOR>
void GUiterateGridVertices(const GU_GridT<INT_TYPE> &grid, FUNCTOR &&functor)
{
    using PrimitiveType = typename GU_GridT<INT_TYPE>::PrimitiveType;
    if (grid.myPrimitiveType == PrimitiveType::POINTS)
        return;

    const GEO_SurfaceType surface_type = grid.mySurfaceType;
    const bool rows_and_cols = (surface_type == GEO_PATCH_ROWCOL);
    const exint nedgerows = grid.myNumEdgeRows;
    const exint nedgecols = grid.myNumEdgeCols;

    if (nedgerows < 0 || nedgecols < 0)
        return;

    exint primnum = 0;
    exint vtxnum = 0;

    if (grid.isInvalidTPSurf())
        return;

    if (grid.myPrimitiveType != PrimitiveType::POLYGON)
    {
        // Single primitive
        // FIXME: Support myCurvesIfBasisRowCol!
        // "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;
        for (exint row = 0; row < nedgerows; ++row)
        {
            for (exint col = 0; col < nedgecols; ++col)
            {
                functor(vtxnum, row, col, false, false, primnum, vtxnum);
                ++vtxnum;
            }

            if (has_endcol)
            {
                functor(vtxnum, row, nedgecols-1, false, true, primnum, vtxnum);
                ++vtxnum;
            }
        }

        if (has_endrow)
        {
            for (exint col = 0; col < nedgecols; ++col)
            {
                functor(vtxnum, nedgerows-1, col, true, false, primnum, vtxnum);
                ++vtxnum;
            }

            if (has_endcol)
            {
                functor(vtxnum, nedgerows-1, nedgecols-1, true, true, primnum, vtxnum);
                ++vtxnum;
            }
        }

        return;
    }

    // Get the special cases out of the way so that it's easier later
    if (nedgerows == 0)
    {
        if (surface_type == GEO_PATCH_ROWS || rows_and_cols)
        {
            if (nedgecols == 0)
            {
                // Single vertex
                functor(vtxnum, 0, 0, false, false, primnum, 0);
                ++vtxnum;
                ++primnum;
            }
            else
            {
                // Single row
                for (exint col = 0; col < nedgecols; ++col, ++vtxnum)
                    functor(vtxnum, 0, col, false, false, primnum, col);

                if (!grid.doesRowWrap(0) || grid.myUnrollCurves)
                {
                    // Last vertex of the curve is treated as end of last edge col.
                    functor(vtxnum, 0, nedgecols-1, false, true, primnum, nedgecols);
                    ++vtxnum;
                }
                ++primnum;
            }
            if (!rows_and_cols)
                return;
        }
        if (surface_type == GEO_PATCH_COLS || rows_and_cols)
        {
            if (nedgecols == 0)
            {
                // Single vertex
                functor(vtxnum, 0, 0, false, false, primnum, 0);
                ++vtxnum;
                ++primnum;
            }
            else
            {
                // Single row
                for (exint col = 0; col < nedgecols; ++col, ++vtxnum, ++primnum)
                    functor(vtxnum, 0, col, false, false, primnum, 0);

                if (!grid.doesRowWrap(0))
                {
                    // Last vertex of the curve is treated as end of last edge col.
                    functor(vtxnum, 0, nedgecols-1, false, true, primnum, 0);
                    ++vtxnum;
                    ++primnum;
                }
            }
        }
        // Only rows, cols, and rowcol have vertices when a single row.
        return;
    }

    if (nedgecols == 0)
    {
        if (surface_type == GEO_PATCH_ROWS || rows_and_cols)
        {
            // Single col
            for (exint row = 0; row < nedgerows; ++row, ++vtxnum, ++primnum)
                functor(vtxnum, row, 0, false, false, primnum, 0);

            if (!grid.doesColWrap(0))
            {
                // Last vertex of the curve is treated as end of last edge row.
                functor(vtxnum, nedgerows-1, 0, true, false, primnum, 0);
                ++vtxnum;
                ++primnum;
            }
            if (!rows_and_cols)
                return;
        }
        if (surface_type == GEO_PATCH_COLS || rows_and_cols)
        {
            // Single col
            for (exint row = 0; row < nedgerows; ++row, ++vtxnum)
                functor(vtxnum, row, 0, false, false, primnum, row);

            if (!grid.doesColWrap(0) || grid.myUnrollCurves)
            {
                // Last vertex of the curve is treated as end of last edge row.
                functor(vtxnum, nedgerows-1, 0, true, false, primnum, nedgerows);
                ++vtxnum;
            }
        }
        // Only rows, cols, and rowcol have vertices when a single col.
        return;
    }

    // Main cases; note that nedgerows and nedgecols are both at least 1.

    if (surface_type == GEO_PATCH_ROWS || rows_and_cols)
    {
        exint first_row = (grid.myNoWrapV && !grid.myFirstRowIfNotWrapped);
        for (exint row = first_row; row < nedgerows; ++row, ++primnum)
        {
            for (exint col = 0; col < nedgecols; ++col, ++vtxnum)
                functor(vtxnum, row, col, false, false, primnum, col);

            if (!grid.doesRowWrap(row) || grid.myUnrollCurves)
            {
                // Last vertex of the curve is treated as end of last edge col.
                functor(vtxnum, row, nedgecols-1, false, true, primnum, nedgecols);
                ++vtxnum;
            }
        }

        if (!grid.myAllWrapV && grid.myLastRowIfNotWrapped)
        {
            exint primvtx = 0;
            bool col_wraps = grid.doesColWrap(0);
            bool next_col_wraps;
            for (exint col = 0; col < nedgecols; ++col, col_wraps = next_col_wraps)
            {
                next_col_wraps = grid.doesColWrap(col+1);
                bool currently_in_a_curve = (primvtx != 0);
                if (!currently_in_a_curve)
                {
                    if (col_wraps && next_col_wraps)
                    {
                        // If current point and next point are wrapping v,
                        // and we're not currently in a curve, skip.
                        // O=======(O)=======O
                        continue;
                    }

                    // (O)------O           //
                    // (O)------O           //
                    //     or               //
                    // (O)-----\            //
                    // (O)------O           //
                    //     or               //
                    //            /------O  //
                    // O=======(O)-------O  //
                    functor(vtxnum, nedgerows-1, col, true, false, primnum, 0);
                    ++vtxnum;
                    primvtx = 1;
                }
                else if (col_wraps && next_col_wraps)
                {
                    // O------\             //
                    // O-------(O)=======O  //
                    functor(vtxnum, nedgerows-1, col, true, false, primnum, primvtx);
                    ++vtxnum;
                    ++primnum;
                    primvtx = 0;
                }
                else
                {
                    // O------\   /------O  //
                    // O-------(O)-------O  //
                    //     or               //
                    // O-------(O)-------O  //
                    // O--------O--------O  //
                    //     or               //
                    // O-------(O)------\   //
                    // O--------O--------O  //
                    functor(vtxnum, nedgerows-1, col, true, false, primnum, primvtx);
                    ++vtxnum;
                    ++primvtx;
                }
            }
            if ((!grid.doesRowWrap(nedgerows) || grid.myUnrollCurves) && (primvtx != 0))
            {
                // O-------(O)  //
                // O-------(O)  //
                //     or       //
                // O------\     //
                // O-------(O)  //
                //     or       //
                //  /------(O)  //
                // O-------(O)  //
                functor(vtxnum, nedgerows-1, nedgecols-1, true, true, primnum, primvtx);
                ++vtxnum;
                ++primnum;
                primvtx = 0;
            }
        }

        if (!rows_and_cols)
            return;
    }
    if (surface_type == GEO_PATCH_COLS || rows_and_cols)
    {
        // Just like the rows case, but with rows and cols (mostly) swapped
        exint first_col = (grid.myNoWrapU && !grid.myFirstColIfNotWrapped);
        for (exint col = first_col; col < nedgecols; ++col, ++primnum)
        {
            for (exint row = 0; row < nedgerows; ++row, ++vtxnum)
                functor(vtxnum, row, col, false, false, primnum, row);

            if (!grid.doesColWrap(col) || grid.myUnrollCurves)
            {
                // Last vertex of the curve is treated as end of last edge row.
                functor(vtxnum, nedgerows-1, col, true, false, primnum, nedgerows);
                ++vtxnum;
            }
        }

        if (!grid.myAllWrapU && grid.myLastColIfNotWrapped)
        {
            exint primvtx = 0;
            bool row_wraps = grid.doesRowWrap(0);
            bool next_row_wraps;
            for (exint row = 0; row < nedgerows; ++row, row_wraps = next_row_wraps)
            {
                next_row_wraps = grid.doesRowWrap(row+1);
                bool currently_in_a_curve = (primvtx != 0);
                if (!currently_in_a_curve)
                {
                    if (row_wraps && next_row_wraps)
                    {
                        // If current point and next point are wrapping u,
                        // and we're not currently in a curve, skip.
                        // O=======(O)=======O
                        continue;
                    }

                    // (O)------O           //
                    // (O)------O           //
                    //     or               //
                    // (O)-----\            //
                    // (O)------O           //
                    //     or               //
                    //            /------O  //
                    // O=======(O)-------O  //
                    functor(vtxnum, row, nedgecols-1, false, true, primnum, 0);
                    ++vtxnum;
                    primvtx = 1;
                }
                else if (row_wraps && next_row_wraps)
                {
                    // O------\             //
                    // O-------(O)=======O  //
                    functor(vtxnum, row, nedgecols-1, false, true, primnum, primvtx);
                    ++vtxnum;
                    ++primnum;
                    primvtx = 0;
                }
                else
                {
                    // O------\   /------O  //
                    // O-------(O)-------O  //
                    //     or               //
                    // O-------(O)-------O  //
                    // O--------O--------O  //
                    //     or               //
                    // O-------(O)------\   //
                    // O--------O--------O  //
                    functor(vtxnum, row, nedgecols-1, false, true, primnum, primvtx);
                    ++vtxnum;
                    ++primvtx;
                }
            }
            if ((!grid.doesColWrap(nedgecols) || grid.myUnrollCurves) && (primvtx != 0))
            {
                // O-------(O)  //
                // O-------(O)  //
                //     or       //
                // O------\     //
                // O-------(O)  //
                //     or       //
                //  /------(O)  //
                // O-------(O)  //
                functor(vtxnum, nedgerows-1, nedgecols-1, true, true, primnum, primvtx);
                ++vtxnum;
                ++primnum;
                primvtx = 0;
            }
        }
        return;
    }

    const bool alt = (surface_type == GEO_PATCH_ALTTRIANGLE);
    const bool rev = (surface_type == GEO_PATCH_REVTRIANGLE);

    UT_ASSERT_MSG(nedgerows >= 1 && nedgecols >= 1, "Caller should have switched quads to rows or cols");
    if (!grid.myTriangularPoles)
    {
        if (surface_type == GEO_PATCH_QUADS)
        {
            // All quads: simple.
            for (exint row = 0, primnum = 0; row < nedgerows; ++row)
            {
                for (exint col = 0; col < nedgecols; ++col, ++primnum, vtxnum+=4)
                {
                    functor(vtxnum  , row, col, false, false, primnum, 0);
                    functor(vtxnum+1, row, col, false, true,  primnum, 1);
                    functor(vtxnum+2, row, col, true,  true,  primnum, 2);
                    functor(vtxnum+3, row, col, true,  false, primnum, 3);
                }
            }
            return;
        }

        // All tris in the form of quads: simple.
        for (exint row = 0, primnum = 0; row < nedgerows; ++row)
        {
            for (exint col = 0; col < nedgecols; ++col, primnum+=2, vtxnum+=6)
            {
                // Switch diagonal with checkerboard pattern
                const bool switched = (rev || (alt && ((row^col)&1)));

                functor(vtxnum  , row, col, false, false,     primnum  , 0);
                functor(vtxnum+1, row, col, false, true,      primnum  , 1);
                functor(vtxnum+2, row, col, true,  !switched, primnum  , 2);

                functor(vtxnum+3, row, col, false, switched,  primnum+1, 0);
                functor(vtxnum+4, row, col, true,  true,      primnum+1, 1);
                functor(vtxnum+5, row, col, true,  false,     primnum+1, 2);
            }
        }
        return;
    }

    // grid.myTriangularPoles is true, which means that any
    // adjacent duplicate points on the boundary will result in triangles,
    // instead of quads.  The big caveat is that if there's only one edge row
    // or only one edge column, things get messy.  The smaller caveat is that if
    // the 3 points of a corner are all the same point, there'd be a degenerate
    // triangle that should probably be removed, so we will.  To deal with
    // both at the same time, we just deal with all boundary quads the same way.

    auto &&boundary_quad = [&grid,surface_type,&functor,rev,alt](exint &vtxnum, exint row, exint col, exint &primnum)
    {
        // Single "quad", but removing degeneracies.

        INT_TYPE points[4];
        points[0] = grid.getPoint(row,   col  );
        points[1] = grid.getPoint(row,   col+1);
        points[2] = grid.getPoint(row+1, col  );
        points[3] = grid.getPoint(row+1, col+1);

        // If the diagonally opposite points are the same, degenerate.
        if (points[0] == points[2] || points[1] == points[3])
            return;

        const bool row0_equal = (points[0] == points[1]);
        const bool row1_equal = (points[2] == points[3]);
        const bool col0_equal = (points[0] == points[2]);
        const bool col1_equal = (points[1] == points[3]);
        // Both ends equal, so degenerate.
        if ((row0_equal && row1_equal) || (col0_equal && col1_equal))
            return;

        if (!row0_equal && !row1_equal && !col0_equal && !col1_equal)
        {
            // Just a quad
            if (surface_type == GEO_PATCH_QUADS)
            {
                functor(vtxnum  , row, col, false, false, primnum, 0);
                functor(vtxnum+1, row, col, false, true,  primnum, 1);
                functor(vtxnum+2, row, col, true,  true,  primnum, 2);
                functor(vtxnum+3, row, col, true,  false, primnum, 3);
                ++primnum;
                vtxnum += 4;
            }
            else
            {
                // Switch diagonal with checkerboard pattern
                const bool switched = (rev || (alt && ((row^col)&1)));

                functor(vtxnum  , row, col, false, false,     primnum  , 0);
                functor(vtxnum+1, row, col, false, true,      primnum  , 1);
                functor(vtxnum+2, row, col, true,  !switched, primnum  , 2);

                functor(vtxnum+3, row, col, false, switched,  primnum+1, 0);
                functor(vtxnum+4, row, col, true,  true,      primnum+1, 1);
                functor(vtxnum+5, row, col, true,  false,     primnum+1, 2);
                primnum += 2;
                vtxnum += 6;
            }
            return;
        }

        // Exactly one adjacent equal pair, so a triangle
        functor(vtxnum, row, col, false, false, primnum, vtxnum);
        ++vtxnum;
        if (!row0_equal)
        {
            functor(vtxnum, row, col, false, true,  primnum, vtxnum);
            ++vtxnum;
        }
        if (!row1_equal && !col1_equal)
        {
            functor(vtxnum, row, col, true,  true,  primnum, vtxnum);
            ++vtxnum;
        }
        if (!col0_equal)
        {
            functor(vtxnum, row, col, true,  false, primnum, vtxnum);
            ++vtxnum;
        }
        ++primnum;
    };

    exint row = 0;
    for (exint col = 0; col < nedgecols; ++col)
    {
        boundary_quad(vtxnum, row, col, primnum);
    }
    for (row = 1; row < nedgerows-1; ++row)
    {
        exint col = 0;
        boundary_quad(vtxnum, row, col, primnum);

        // Interior quads (tris) as normal, ignoring any potential degeneracy.
        if (surface_type == GEO_PATCH_QUADS)
        {
            for (col = 1; col < nedgecols-1; ++col, ++primnum, vtxnum+=4)
            {
                functor(vtxnum  , row, col, false, false, primnum, 0);
                functor(vtxnum+1, row, col, false, true,  primnum, 1);
                functor(vtxnum+2, row, col, true,  true,  primnum, 2);
                functor(vtxnum+3, row, col, true,  false, primnum, 3);
            }
        }
        else
        {
            for (col = 1; col < nedgecols-1; ++col, primnum+=2, vtxnum+=6)
            {
                // Switch diagonal with checkerboard pattern
                const bool switched = (rev || (alt && ((row^col)&1)));

                functor(vtxnum  , row, col, false, false,     primnum  , 0);
                functor(vtxnum+1, row, col, false, true,      primnum  , 1);
                functor(vtxnum+2, row, col, true,  !switched, primnum  , 2);

                functor(vtxnum+3, row, col, false, switched,  primnum+1, 0);
                functor(vtxnum+4, row, col, true,  true,      primnum+1, 1);
                functor(vtxnum+5, row, col, true,  false,     primnum+1, 2);
            }
        }

        boundary_quad(vtxnum, row, col, primnum);
    }
    for (exint col = 0; col < nedgecols; ++col)
    {
        boundary_quad(vtxnum, row, col, primnum);
    }
}

template<typename INT_TYPE>
void GU_GridT<INT_TYPE>::precompute()
{
    const exint nedgerows = myNumEdgeRows;
    const exint nedgecols = myNumEdgeCols;
    if (nedgerows < 0 || nedgecols < 0 || (nedgerows == 0 && nedgecols == 0))
    {
        myNoWrapU = true;
        myNoWrapV = true;
        myAllWrapU = false;
        myAllWrapV = false;
        return;
    }
    if (nedgerows == 0)
    {
        const bool wrapu = (myCorners[0] == myCorners[1]);
        myNoWrapU = !wrapu;
        myNoWrapV = true;
        myAllWrapU = wrapu;
        myAllWrapV = false;
        return;
    }
    if (nedgecols == 0)
    {
        const bool wrapv = (myCorners[0] == myCorners[2]);
        myNoWrapU = true;
        myNoWrapV = !wrapv;
        myAllWrapU = false;
        myAllWrapV = wrapv;
        return;
    }

    bool wrapu0 = (myCorners[0] == myCorners[1]);
    bool wrapu1 = (myCorners[2] == myCorners[3]);
    bool has_wrapu = wrapu0 || wrapu1;
    bool has_notwrapu = !wrapu0 || !wrapu1;

    bool wrapv0 = (myCorners[0] == myCorners[2]);
    bool wrapv1 = (myCorners[1] == myCorners[3]);
    bool has_wrapv = wrapv0 || wrapv1;
    bool has_notwrapv = !wrapv0 || !wrapv1;

    if ((myCol0Start < INT_TYPE(0)) || (myCol1Start < INT_TYPE(0)) || (myCol0Step != myCol1Step))
    {
        // Uncommon case: iterate to check.
        for (exint rowm1 = 0; rowm1 < nedgerows-1; ++rowm1)
        {
            INT_TYPE pt0 = (myCol0Start < INT_TYPE(0)) ? myCol0Array[rowm1] : (myCol0Start + myCol0Step*rowm1);
            INT_TYPE pt1 = (myCol1Start < INT_TYPE(0)) ? myCol1Array[rowm1] : (myCol1Start + myCol1Step*rowm1);
            bool wrapu = (pt0 == pt1);
            has_wrapu |= wrapu;
            has_notwrapu |= !wrapu;
        }
    }
    else
    {
        // Common case: uniform step.
        bool wrapu = (myCol0Start == myCol1Start);
        has_wrapu |= wrapu;
        has_notwrapu |= !wrapu;
    }

    if ((myRow0Start < INT_TYPE(0)) || (myRow1Start < INT_TYPE(0)) || (myRow0Step != myRow1Step))
    {
        // Uncommon case: iterate to check.
        for (exint colm1 = 0; colm1 < nedgecols-1; ++colm1)
        {
            INT_TYPE pt0 = (myRow0Start < INT_TYPE(0)) ? myRow0Array[colm1] : (myRow0Start + myRow0Step*colm1);
            INT_TYPE pt1 = (myRow1Start < INT_TYPE(0)) ? myRow1Array[colm1] : (myRow1Start + myRow1Step*colm1);
            bool wrapv = (pt0 == pt1);
            has_wrapv |= wrapv;
            has_notwrapv |= !wrapv;
        }
    }
    else
    {
        // Common case: uniform step.
        bool wrapv = (myRow0Start == myRow1Start);
        has_wrapv |= wrapv;
        has_notwrapv |= !wrapv;
    }

    myAllWrapU = !has_notwrapu;
    myAllWrapV = !has_notwrapv;
    myNoWrapU = !has_wrapu;
    myNoWrapV = !has_wrapv;
}

template<typename INT_TYPE>
void GU_GridT<INT_TYPE>::initSingleGrid(
    exint nedgerows, exint nedgecols, INT_TYPE start_pt)
{
    clear();

    myNumEdgeRows = nedgerows;
    myNumEdgeCols = nedgecols;

    myAllWrapU = false;
    myAllWrapV = false;
    myNoWrapU = true;
    myNoWrapV = true;

    fixTPSurf();

    myCorners[0] = start_pt;
    myCorners[1] = start_pt + nedgecols;
    myCorners[2] = start_pt + nedgerows*(nedgecols+1);
    myCorners[3] = start_pt + nedgerows*(nedgecols+1) + nedgecols;

    myRow0Step = INT_TYPE(1);
    myRow0Start = myCorners[0]+myRow0Step;
    myRow1Step = INT_TYPE(1);
    myRow1Start = myCorners[2]+myRow1Step;

    myCol0Step = INT_TYPE(nedgecols+1);
    myCol0Start = myCorners[0]+myCol0Step;
    myCol1Step = INT_TYPE(nedgecols+1);
    myCol1Start = myCorners[1]+myCol1Step;

    myMiddleStart = myCol0Start+1;
    myMiddleColStep = myRow0Step;
    myMiddleRowStep = myCol0Step;

    if (myPrimitiveType == PrimitiveType::POINTS)
    {
        myNumPrimitives = 0;
        myNumVertices = 0;
        return;
    }

    if (myPrimitiveType != PrimitiveType::POLYGON)
    {
        // Single primitive
        myNumPrimitives = 1;

        // FIXME: Support myCurvesIfBasisRowCol!

        // 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 = myNoWrapV || myUnrollCurves;
        const bool has_endcol = myNoWrapU || myUnrollCurves;
        const exint nvtxrows = myNumEdgeRows + exint(has_endrow);
        const exint nvtxcols = myNumEdgeCols + exint(has_endcol);
        myNumVertices = nvtxrows*nvtxcols;
        return;
    }

    if (mySurfaceType == GEO_PATCH_QUADS)
    {
        myNumPrimitives = myNumEdgeRows*myNumEdgeCols;
        myNumVertices = 4*myNumPrimitives;
        return;
    }

    // Initialize to zero, so that cols and rowcol case can use +=
    myNumPrimitives = 0;
    myNumVertices = 0;
    if (mySurfaceType == GEO_PATCH_ROWS || mySurfaceType == GEO_PATCH_ROWCOL)
    {
        myNumPrimitives = myNumEdgeRows-1 + exint(myFirstRowIfNotWrapped) + exint(myLastRowIfNotWrapped);
        myNumVertices = myNumPrimitives*(myNumEdgeCols+1);
        if (mySurfaceType != GEO_PATCH_ROWCOL)
            return;
    }
    if (mySurfaceType == GEO_PATCH_COLS || mySurfaceType == GEO_PATCH_ROWCOL)
    {
        exint col_polys = myNumEdgeCols-1 + exint(myFirstColIfNotWrapped) + exint(myLastColIfNotWrapped);
        myNumPrimitives += col_polys;
        myNumVertices += col_polys*(myNumEdgeRows+1);
        return;
    }

    // Triangles
    myNumPrimitives = 2*myNumEdgeRows*myNumEdgeCols;
    myNumVertices = 3*myNumPrimitives;
}

template<typename INT_TYPE>
void GU_GridT<INT_TYPE>::initColTube(
    exint nedgerows, exint nedgecols, INT_TYPE start_pt)
{
    clear();

    myNumEdgeRows = nedgerows;
    myNumEdgeCols = nedgecols;

    myAllWrapU = true;
    myAllWrapV = false;
    myNoWrapU = false;
    myNoWrapV = true;

    fixTPSurf();

    myCorners[0] = start_pt;
    myCorners[1] = myCorners[0];
    myCorners[2] = start_pt + nedgerows*nedgecols;
    myCorners[3] = myCorners[2];

    myRow0Step = INT_TYPE(1);
    myRow0Start = myCorners[0]+myRow0Step;
    myRow1Step = INT_TYPE(1);
    myRow1Start = myCorners[2]+myRow1Step;

    myCol0Step = INT_TYPE(nedgecols);
    myCol0Start = myCorners[0]+myCol0Step;
    myCol1Step = INT_TYPE(nedgecols);
    myCol1Start = myCorners[1]+myCol1Step;

    myMiddleStart = myCol0Start+1;
    myMiddleColStep = myRow0Step;
    myMiddleRowStep = myCol0Step;

    if (myPrimitiveType == PrimitiveType::POINTS)
    {
        myNumPrimitives = 0;
        myNumVertices = 0;
        return;
    }

    if (myPrimitiveType != PrimitiveType::POLYGON)
    {
        // Single primitive
        myNumPrimitives = 1;

        // FIXME: Support myCurvesIfBasisRowCol!

        // 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 = myNoWrapV || myUnrollCurves;
        const bool has_endcol = myNoWrapU || myUnrollCurves;
        const exint nvtxrows = myNumEdgeRows + exint(has_endrow);
        const exint nvtxcols = myNumEdgeCols + exint(has_endcol);
        myNumVertices = nvtxrows*nvtxcols;
        return;
    }

    if (mySurfaceType == GEO_PATCH_QUADS)
    {
        myNumPrimitives = myNumEdgeRows*myNumEdgeCols;
        myNumVertices = 4*myNumPrimitives;
        return;
    }

    // Initialize to zero, so that cols and rowcol case can use +=
    myNumPrimitives = 0;
    myNumVertices = 0;
    if (mySurfaceType == GEO_PATCH_ROWS || mySurfaceType == GEO_PATCH_ROWCOL)
    {
        myNumPrimitives = myNumEdgeRows-1 + exint(myFirstRowIfNotWrapped) + exint(myLastRowIfNotWrapped);
        myNumVertices = myNumPrimitives*(myNumEdgeCols+myUnrollCurves);
        if (mySurfaceType != GEO_PATCH_ROWCOL)
            return;
    }
    if (mySurfaceType == GEO_PATCH_COLS || mySurfaceType == GEO_PATCH_ROWCOL)
    {
        myNumPrimitives += myNumEdgeCols;
        myNumVertices += myNumEdgeCols*(myNumEdgeRows+1);
        return;
    }

    // Triangles
    myNumPrimitives = 2*myNumEdgeRows*myNumEdgeCols;
    myNumVertices = 3*myNumPrimitives;
}

template<typename INT_TYPE>
void GU_GridT<INT_TYPE>::initRowTube(
    exint nedgerows, exint nedgecols, INT_TYPE start_pt)
{
    clear();

    myNumEdgeRows = nedgerows;
    myNumEdgeCols = nedgecols;

    myAllWrapU = false;
    myAllWrapV = true;
    myNoWrapU = true;
    myNoWrapV = false;

    fixTPSurf();

    myCorners[0] = start_pt;
    myCorners[1] = start_pt + nedgecols;
    myCorners[2] = myCorners[0];
    myCorners[3] = myCorners[1];

    myRow0Step = INT_TYPE(1);
    myRow0Start = myCorners[0]+myRow0Step;
    myRow1Step = INT_TYPE(1);
    myRow1Start = myCorners[2]+myRow1Step;

    myCol0Step = INT_TYPE(nedgecols+1);
    myCol0Start = myCorners[0]+myCol0Step;
    myCol1Step = INT_TYPE(nedgecols+1);
    myCol1Start = myCorners[1]+myCol1Step;

    myMiddleStart = myCol0Start+1;
    myMiddleColStep = myRow0Step;
    myMiddleRowStep = myCol0Step;

    if (myPrimitiveType == PrimitiveType::POINTS)
    {
        myNumPrimitives = 0;
        myNumVertices = 0;
        return;
    }

    if (myPrimitiveType != PrimitiveType::POLYGON)
    {
        // Single primitive
        myNumPrimitives = 1;

        // FIXME: Support myCurvesIfBasisRowCol!

        // 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 = myNoWrapV || myUnrollCurves;
        const bool has_endcol = myNoWrapU || myUnrollCurves;
        const exint nvtxrows = myNumEdgeRows + exint(has_endrow);
        const exint nvtxcols = myNumEdgeCols + exint(has_endcol);
        myNumVertices = nvtxrows*nvtxcols;
        return;
    }

    if (mySurfaceType == GEO_PATCH_QUADS)
    {
        myNumPrimitives = myNumEdgeRows*myNumEdgeCols;
        myNumVertices = 4*myNumPrimitives;
        return;
    }

    // Initialize to zero, so that cols and rowcol case can use +=
    myNumPrimitives = 0;
    myNumVertices = 0;
    if (mySurfaceType == GEO_PATCH_ROWS || mySurfaceType == GEO_PATCH_ROWCOL)
    {
        myNumPrimitives = myNumEdgeRows;
        myNumVertices = myNumPrimitives*(myNumEdgeCols+1);
        if (mySurfaceType != GEO_PATCH_ROWCOL)
            return;
    }
    if (mySurfaceType == GEO_PATCH_COLS || mySurfaceType == GEO_PATCH_ROWCOL)
    {
        exint col_polys = myNumEdgeCols-1 + exint(myFirstColIfNotWrapped) + exint(myLastColIfNotWrapped);
        myNumPrimitives += col_polys;
        myNumVertices += col_polys*(myNumEdgeRows+myUnrollCurves);
        return;
    }

    // Triangles
    myNumPrimitives = 2*myNumEdgeRows*myNumEdgeCols;
    myNumVertices = 3*myNumPrimitives;
}

template<typename INT_TYPE>
void GU_GridT<INT_TYPE>::initColSphere(
    exint nedgerows, exint nedgecols,
    INT_TYPE start_pt, INT_TYPE end_pt, INT_TYPE start_mid_pt)
{
    clear();

    myNumEdgeRows = nedgerows;
    myNumEdgeCols = nedgecols;

    myAllWrapU = true;
    myAllWrapV = false;
    myNoWrapU = false;
    myNoWrapV = true;

    fixTPSurf();

    myCorners[0] = start_pt;
    myCorners[1] = myCorners[0];
    myCorners[2] = end_pt;
    myCorners[3] = myCorners[2];

    myRow0Step = INT_TYPE(0);
    myRow0Start = start_pt;
    myRow1Step = INT_TYPE(0);
    myRow1Start = end_pt;

    myCol0Step = INT_TYPE(nedgecols);
    myCol0Start = start_mid_pt;
    myCol1Step = INT_TYPE(nedgecols);
    myCol1Start = start_mid_pt;

    myMiddleStart = myCol0Start+1;
    myMiddleColStep = INT_TYPE(1);
    myMiddleRowStep = INT_TYPE(nedgecols);

    if (myPrimitiveType == PrimitiveType::POINTS)
    {
        myNumPrimitives = 0;
        myNumVertices = 0;
        return;
    }

    if (myPrimitiveType != PrimitiveType::POLYGON)
    {
        // Single primitive
        myNumPrimitives = 1;

        // FIXME: Support myCurvesIfBasisRowCol!

        // 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 = myNoWrapV || myUnrollCurves;
        const bool has_endcol = myNoWrapU || myUnrollCurves;
        const exint nvtxrows = myNumEdgeRows + exint(has_endrow);
        const exint nvtxcols = myNumEdgeCols + exint(has_endcol);
        myNumVertices = nvtxrows*nvtxcols;
        return;
    }

    if (mySurfaceType == GEO_PATCH_QUADS)
    {
        myNumPrimitives = myNumEdgeRows*myNumEdgeCols;
        myNumVertices = 4*myNumPrimitives - (myTriangularPoles ? 2*myNumEdgeCols : 0);
        return;
    }

    // Initialize to zero, so that cols and rowcol case can use +=
    myNumPrimitives = 0;
    myNumVertices = 0;
    if (mySurfaceType == GEO_PATCH_ROWS || mySurfaceType == GEO_PATCH_ROWCOL)
    {
        const exint rowprims = myNumEdgeRows-1 + exint(myFirstRowIfNotWrapped) + exint(myLastRowIfNotWrapped);
        myNumPrimitives = rowprims;
        myNumVertices = rowprims*(myNumEdgeCols+myUnrollCurves);
        if (mySurfaceType != GEO_PATCH_ROWCOL)
            return;
    }
    if (mySurfaceType == GEO_PATCH_COLS || mySurfaceType == GEO_PATCH_ROWCOL)
    {
        myNumPrimitives += myNumEdgeCols;
        myNumVertices += myNumEdgeCols*(myNumEdgeRows+1);
        return;
    }

    // Triangles
    myNumPrimitives = (myNumEdgeRows - exint(myTriangularPoles))*2*myNumEdgeCols;
    myNumVertices = 3*myNumPrimitives;
}

template<typename INT_TYPE>
void GU_GridT<INT_TYPE>::initRowSphere(
    exint nedgerows, exint nedgecols,
    INT_TYPE start_pt, INT_TYPE end_pt, INT_TYPE start_mid_pt)
{
    clear();

    myNumEdgeRows = nedgerows;
    myNumEdgeCols = nedgecols;

    myAllWrapU = false;
    myAllWrapV = true;
    myNoWrapU = true;
    myNoWrapV = false;

    fixTPSurf();

    myCorners[0] = start_pt;
    myCorners[1] = end_pt;
    myCorners[2] = start_pt;
    myCorners[3] = end_pt;

    myRow0Step = INT_TYPE(1);
    myRow0Start = start_mid_pt;
    myRow1Step = INT_TYPE(1);
    myRow1Start = start_mid_pt;

    myCol0Step = INT_TYPE(0);
    myCol0Start = start_pt;
    myCol1Step = INT_TYPE(0);
    myCol1Start = end_pt;

    myMiddleStart = myRow0Start+nedgecols-1;
    myMiddleColStep = INT_TYPE(1);
    myMiddleRowStep = INT_TYPE(nedgecols-1);

    if (myPrimitiveType == PrimitiveType::POINTS)
    {
        myNumPrimitives = 0;
        myNumVertices = 0;
        return;
    }

    if (myPrimitiveType != PrimitiveType::POLYGON)
    {
        // Single primitive
        myNumPrimitives = 1;

        // FIXME: Support myCurvesIfBasisRowCol!

        // 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 = myNoWrapV || myUnrollCurves;
        const bool has_endcol = myNoWrapU || myUnrollCurves;
        const exint nvtxrows = myNumEdgeRows + exint(has_endrow);
        const exint nvtxcols = myNumEdgeCols + exint(has_endcol);
        myNumVertices = nvtxrows*nvtxcols;
        return;
    }

    if (mySurfaceType == GEO_PATCH_QUADS)
    {
        myNumPrimitives = myNumEdgeRows*myNumEdgeCols;
        myNumVertices = 4*myNumPrimitives - (myTriangularPoles ? 2*myNumEdgeRows : 0);
        return;
    }

    // Initialize to zero, so that cols and rowcol case can use +=
    myNumPrimitives = 0;
    myNumVertices = 0;
    if (mySurfaceType == GEO_PATCH_ROWS || mySurfaceType == GEO_PATCH_ROWCOL)
    {
        myNumPrimitives = myNumEdgeRows;
        myNumVertices = myNumEdgeRows*(myNumEdgeCols+1);
        if (mySurfaceType != GEO_PATCH_ROWCOL)
            return;
    }
    if (mySurfaceType == GEO_PATCH_COLS || mySurfaceType == GEO_PATCH_ROWCOL)
    {
        const exint colprims = myNumEdgeCols-1 + exint(myFirstColIfNotWrapped) + exint(myLastColIfNotWrapped);
        myNumPrimitives += colprims;
        myNumVertices += colprims*(myNumEdgeRows+myUnrollCurves);
        return;
    }

    // Triangles
    myNumPrimitives = myNumEdgeRows*2*(myNumEdgeCols - exint(myTriangularPoles));
    myNumVertices = 3*myNumPrimitives;
}

template<typename INT_TYPE>
void GU_GridT<INT_TYPE>::initSplitRowSphere(
    exint nedgerows, exint nedgecols,
    INT_TYPE start_pt, INT_TYPE end_pt, INT_TYPE start_mid_pt)
{
    clear();

    myNumEdgeRows = nedgerows;
    myNumEdgeCols = nedgecols;

    // Same wrapping settings as initSplitColSphere
    myAllWrapU = false;
    myAllWrapV = false;
    myNoWrapU = true;
    myNoWrapV = true;

    fixTPSurf();

    // Same corner orientation as initRowSphere
    myCorners[0] = start_pt;
    myCorners[1] = end_pt;
    myCorners[2] = start_pt;
    myCorners[3] = end_pt;

    // Used when stepping along the open seams of the sphere.
    // The steps in this direction should be continuous since 
    // the rows and columns are swapped.  This is the open 
    // version of initRowSphere.
    myRow0Step = INT_TYPE(1);
    myRow0Start = start_mid_pt;
    myRow1Step = INT_TYPE(1);
    myRow1Start = end_pt - nedgecols + 1;

    // Used when stepping along the pole of the sphere; 
    // hence, the zero step which gives one point for each 
    // of these rows.  It is the transposed version of 
    // initSplitColSphere.
    myCol0Step = INT_TYPE(0);
    myCol0Start = start_pt;
    myCol1Step = INT_TYPE(0);
    myCol1Start = end_pt;

    // This gives the proper transposition of points when 
    // stepping along the interior of the grid with 
    // swapped rows and columns.  This is the open 
    // version of initRowSphere.
    myMiddleStart = INT_TYPE(start_mid_pt + nedgecols - 1);
    myMiddleColStep = INT_TYPE(1);
    myMiddleRowStep = INT_TYPE(nedgecols - 1);

    if (myPrimitiveType == PrimitiveType::POINTS)
    {
        myNumPrimitives = 0;
        myNumVertices = 0;
        return;
    }

    // Similar code used in companion functions
    if (myPrimitiveType != PrimitiveType::POLYGON)
    {
        // Single primitive
        myNumPrimitives = 1;

        // FIXME: Support myCurvesIfBasisRowCol!
        // 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 = myNoWrapV || myUnrollCurves;
        const bool has_endcol = myNoWrapU || myUnrollCurves;
        const exint nvtxrows = myNumEdgeRows + exint(has_endrow);
        const exint nvtxcols = myNumEdgeCols + exint(has_endcol);
        myNumVertices = nvtxrows * nvtxcols;
        return;
    }

    if (mySurfaceType == GEO_PATCH_QUADS)
    {
        myNumPrimitives = myNumEdgeRows * myNumEdgeCols;
        myNumVertices = 4 * myNumPrimitives - (myTriangularPoles ? 2 * myNumEdgeRows : 0);
        return;
    }

    // Initialize to zero, so that cols and rowcol case can use +=
    myNumPrimitives = 0;
    myNumVertices = 0;
    if (mySurfaceType == GEO_PATCH_ROWS || mySurfaceType == GEO_PATCH_ROWCOL)
    {
        // Transpose of initSplitColSphere
        myNumPrimitives = myNumEdgeRows - 1 + exint(myFirstRowIfNotWrapped) + exint(myLastRowIfNotWrapped);
        myNumVertices = (myNumEdgeCols + 1) * (myNumEdgeRows + 1);
        if (mySurfaceType != GEO_PATCH_ROWCOL)
            return;
    }

    if (mySurfaceType == GEO_PATCH_COLS || mySurfaceType == GEO_PATCH_ROWCOL)
    {
        // Transpose of initSplitColSphere
        const exint colprims = myNumEdgeCols - 1 + exint(myFirstColIfNotWrapped) + exint(myLastColIfNotWrapped);
        myNumPrimitives += colprims;
        myNumVertices += colprims * (myNumEdgeRows + 1);
        return;
    }

    // Triangles
    myNumPrimitives = myNumEdgeRows * 2 * (myNumEdgeCols - exint(myTriangularPoles));
    myNumVertices = 3 * myNumPrimitives;
}

template<typename INT_TYPE>
void GU_GridT<INT_TYPE>::initSplitColSphere(
    exint nedgerows, exint nedgecols,
    INT_TYPE start_pt, INT_TYPE end_pt, INT_TYPE start_mid_pt)
{
    clear();

    myNumEdgeRows = nedgerows;
    myNumEdgeCols = nedgecols;

    myAllWrapU = false;
    myAllWrapV = false;
    myNoWrapU = true;
    myNoWrapV = true;

    fixTPSurf();

    myCorners[0] = start_pt;
    myCorners[1] = myCorners[0];
    myCorners[2] = end_pt;
    myCorners[3] = myCorners[2];

    myRow0Step = INT_TYPE(0);
    myRow0Start = start_pt;
    myRow1Step = INT_TYPE(0);
    myRow1Start = end_pt;

    myCol0Step = INT_TYPE(nedgecols+1);
    myCol0Start = start_mid_pt;
    myCol1Step = INT_TYPE(nedgecols+1);
    myCol1Start = start_mid_pt+nedgecols;

    myMiddleStart = myCol0Start+1;
    myMiddleColStep = INT_TYPE(1);
    myMiddleRowStep = INT_TYPE(nedgecols+1);

    if (myPrimitiveType == PrimitiveType::POINTS)
    {
        myNumPrimitives = 0;
        myNumVertices = 0;
        return;
    }

    if (myPrimitiveType != PrimitiveType::POLYGON)
    {
        // Single primitive
        myNumPrimitives = 1;

        // FIXME: Support myCurvesIfBasisRowCol!

        // 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 = myNoWrapV || myUnrollCurves;
        const bool has_endcol = myNoWrapU || myUnrollCurves;
        const exint nvtxrows = myNumEdgeRows + exint(has_endrow);
        const exint nvtxcols = myNumEdgeCols + exint(has_endcol);
        myNumVertices = nvtxrows*nvtxcols;
        return;
    }

    if (mySurfaceType == GEO_PATCH_QUADS)
    {
        myNumPrimitives = myNumEdgeRows*myNumEdgeCols;
        myNumVertices = 4*myNumPrimitives - (myTriangularPoles ? 2*myNumEdgeCols : 0);
        return;
    }

    // Initialize to zero, so that cols and rowcol case can use +=
    myNumPrimitives = 0;
    myNumVertices = 0;
    if (mySurfaceType == GEO_PATCH_ROWS || mySurfaceType == GEO_PATCH_ROWCOL)
    {
        const exint rowprims = myNumEdgeRows-1 + exint(myFirstRowIfNotWrapped) + exint(myLastRowIfNotWrapped);
        myNumPrimitives = rowprims;
        myNumVertices = rowprims*(myNumEdgeCols+1);
        if (mySurfaceType != GEO_PATCH_ROWCOL)
            return;
    }
    if (mySurfaceType == GEO_PATCH_COLS || mySurfaceType == GEO_PATCH_ROWCOL)
    {
        myNumPrimitives += myNumEdgeCols-1 + exint(myFirstColIfNotWrapped) + exint(myLastColIfNotWrapped);
        myNumVertices += (myNumEdgeCols+1)*(myNumEdgeRows+1);
        return;
    }

    // Triangles
    myNumPrimitives = (myNumEdgeRows - exint(myTriangularPoles))*2*myNumEdgeCols;
    myNumVertices = 3*myNumPrimitives;
}

template<typename INT_TYPE>
void GU_GridT<INT_TYPE>::initTorus(
    exint nedgerows, exint nedgecols, INT_TYPE start_pt)
{
    clear();

    myNumEdgeRows = nedgerows;
    myNumEdgeCols = nedgecols;

    myAllWrapU = true;
    myAllWrapV = true;
    myNoWrapU = false;
    myNoWrapV = false;

    fixTPSurf();

    myCorners[0] = start_pt;
    myCorners[1] = start_pt;
    myCorners[2] = start_pt;
    myCorners[3] = start_pt;

    myRow0Step = INT_TYPE(1);
    myRow0Start = myCorners[0]+myRow0Step;
    myRow1Step = INT_TYPE(1);
    myRow1Start = myCorners[2]+myRow1Step;

    myCol0Step = INT_TYPE(nedgecols);
    myCol0Start = myCorners[0]+myCol0Step;
    myCol1Step = INT_TYPE(nedgecols);
    myCol1Start = myCorners[1]+myCol1Step;

    myMiddleStart = myCol0Start+1;
    myMiddleColStep = myRow0Step;
    myMiddleRowStep = myCol0Step;

    if (myPrimitiveType == PrimitiveType::POINTS)
    {
        myNumPrimitives = 0;
        myNumVertices = 0;
        return;
    }

    if (myPrimitiveType != PrimitiveType::POLYGON)
    {
        // Single primitive
        myNumPrimitives = 1;

        // FIXME: Support myCurvesIfBasisRowCol!

        // 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 = myNoWrapV || myUnrollCurves;
        const bool has_endcol = myNoWrapU || myUnrollCurves;
        const exint nvtxrows = myNumEdgeRows + exint(has_endrow);
        const exint nvtxcols = myNumEdgeCols + exint(has_endcol);
        myNumVertices = nvtxrows*nvtxcols;
        return;
    }

    if (mySurfaceType == GEO_PATCH_QUADS)
    {
        myNumPrimitives = myNumEdgeRows*myNumEdgeCols;
        myNumVertices = 4*myNumPrimitives;
        return;
    }

    // Initialize to zero, so that cols and rowcol case can use +=
    myNumPrimitives = 0;
    myNumVertices = 0;
    if (mySurfaceType == GEO_PATCH_ROWS || mySurfaceType == GEO_PATCH_ROWCOL)
    {
        myNumPrimitives = myNumEdgeRows;
        myNumVertices = myNumPrimitives*(myNumEdgeCols+myUnrollCurves);
        if (mySurfaceType != GEO_PATCH_ROWCOL)
            return;
    }
    if (mySurfaceType == GEO_PATCH_COLS || mySurfaceType == GEO_PATCH_ROWCOL)
    {
        myNumPrimitives += myNumEdgeCols;
        myNumVertices += myNumEdgeCols*(myNumEdgeRows+myUnrollCurves);
        return;
    }

    // Triangles
    myNumPrimitives = 2*myNumEdgeRows*myNumEdgeCols;
    myNumVertices = 3*myNumPrimitives;
}