GEO_ExpandGroupUtils.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:        GEO_ExpandGroupUtils.h ( GU Library, C++)
 *
 * COMMENTS:
 */
#ifndef __GEO_ExpandGroupUtils_h__
#define __GEO_ExpandGroupUtils_h__

#include "GEO_API.h"
#include <UT/UT_Map.h>
#include <UT/UT_Array.h>
#include <UT/UT_IntArray.h>
#include <GA/GA_Edge.h>
#include <GA/GA_Types.h>
#include <GA/GA_Attribute.h>
#include <GA/GA_ATIGroupBool.h>
#include <GA/GA_AIFCompare.h>
#include <GA/GA_EdgeGroup.h>
#include <GA/GA_ElementGroup.h>
#include "GEO_Detail.h"

class GEO_API GEO_ExpandGroupUtils
{
public:
    class GEO_API ConnectAttribute {
        public:
            ConnectAttribute(const GA_Attribute * attrib);

            ConnectAttribute(const GA_ElementGroup * group,
                             bool allow_touch = false,
                             const GA_EdgeGroup * edges = nullptr,
                             bool constrain_within_group = false);

            bool isValid() const
            {
                return myAttribOwner != GA_ATTRIB_INVALID;
            }
            GA_AttributeOwner getOwner() const
            {
                return myAttribOwner;
            }
            bool constrainWithinGroup() const
            {
                return myConstrainWithinGroup;
            }

            bool isGroup() const
            {
                return myGroup;
            }

            bool allowTouch() const
            {
                return myAllowTouch;
            }

            bool treatAsEdge() const
            {
                return myEdgeGroup;
            }

            bool canGrowToPrim(GA_Offset prim0_v0,
                               GA_Offset prim0_v1,
                               GA_Offset prim1_v0,
                               GA_Offset prim1_v1,
                               const GEO_Detail & gdp) const;

            bool canGrowToVertex(GA_Offset v0,
                                 GA_Offset v1,
                                 const GEO_Detail & gdp,
                                 GA_GroupType growth_type,
                    UT_Map<GA_Offset, GA_OffsetArray> & adj_map) const;

            bool isEdgeBound(GA_Offset prim0_v0, GA_Offset prim0_v1,
                                GA_Offset prim1_v0, GA_Offset prim1_v1,
                                const GEO_Detail & gdp) const;

            bool isEqual(GA_Offset x0, GA_Offset x1) const;

            bool groupContainsPrim(GA_Offset prim, const GEO_Detail & gdp) const;
            bool groupContainsPoint(GA_Offset pt, const GEO_Detail & gdp) const
            {
                return groupContainsVertex(gdp.pointVertex(pt), gdp, GA_GROUP_POINT);
            }

            bool groupContainsVertex(GA_Offset vtx, const GEO_Detail & gdp) const
            {
                return groupContainsVertex(vtx, gdp, GA_GROUP_VERTEX);
            }

            bool groupContainsEdge(const GA_Edge & e, const GEO_Detail & gdp,
                                    bool strict = true) const
            {
                if (treatAsEdge())
                    return myEdgeGroup->contains(e);

                if (strict)
                    return groupContainsPoint(e.p0(), gdp) &&
                           groupContainsPoint(e.p1(), gdp);

                return groupContainsPoint(e.p0(), gdp) ||
                       groupContainsPoint(e.p1(), gdp);
            }
        private:
            bool groupContainsVertex(GA_Offset vtx,
                                    const GEO_Detail & gdp,
                                    GA_GroupType growth_type) const;

            const GA_Attribute * get() const
            {
                return myAttrib;
            }

            const GA_AIFCompare * getCompare() const
            {
                return myCmpAttrib;
            }

            const GA_Attribute * myAttrib = nullptr;
            const GA_AIFCompare * myCmpAttrib = nullptr;
            const GA_ElementGroup * myGroup = nullptr;
            const GA_EdgeGroup * myEdgeGroup = nullptr;
            GA_AttributeOwner myAttribOwner = GA_ATTRIB_INVALID;
            bool myAllowTouch = false;
            bool myConstrainWithinGroup = false;
    };

    using ConnectAttribArray = UT_Array<ConnectAttribute>;

    // Three functions to find the connectivity in geometry,
    // Split by several connectivity attributes
    static void     getPointConnectivity(
            UT_Array<GA_OffsetArray> & ranges,
            const GA_PointGroup & pts,
            const GEO_Detail & gdp,
            const ConnectAttribArray & attribs);

    static void     getPrimitiveConnectivity(
            UT_Array<GA_OffsetArray> & ranges,
            const GA_PrimitiveGroup & prims,
            const GEO_Detail & gdp,
            const ConnectAttribArray & attribs);

    static void     getVertexConnectivity(
            UT_Array<GA_OffsetArray> & ranges,
            const GA_VertexGroup & vtxs,
            const GEO_Detail & gdp,
            const ConnectAttribArray & attribs);

    // Helper function to help getting vertices on an edge
    static void     getVerticesOnEdge(
                    GA_OffsetArray & vtx_out,
                    const GA_Edge & edge,
                    const GEO_Detail & gdp,
                    GA_OffsetArray & tmp_vtx_1,
                    GA_OffsetArray & tmp_vtx_2);

    /// Functions for just flood filling the existing group.
    /// group: the group to be grown
    /// gdp: the detail
    /// NOTE: this works as if require_share_edge is false.

    static void     floodFillPrimGroup(
                    GA_PrimitiveGroup & prim_group,
                    const GEO_Detail & gdp);

    static void     floodFillPointGroup(
                    GA_PointGroup & point_group,
                    const GEO_Detail & gdp);

    static void     floodFillVertexGroup(
                    GA_VertexGroup & vtx_group,
                    const GEO_Detail & gdp);

    static void     floodFillEdgeGroup(
                    GA_EdgeGroup & edge_group,
                    const GEO_Detail & gdp);


    // Functions to grow a selection of elements N times
    // group: the group to be grown, these functions will modify the group
    //          parameter to contain the resultant after growing N iterations
    // gdp: the detail
    // attrib: a connectivity attribute, if not nullptr, growth is 
    //        contained to connected regions.
    //        If nullptr, connectivity is ignored.
    // limit_iters: if true will only grow a maximum of _iters_ iterations
    //               if false, will grow as far as possible
    
    // Grow a collection of primitives by N iterations
    static void     growPrimGroupNIters(
                    GA_PrimitiveGroup & prim_group,
                    const GEO_Detail & gdp,
                    const ConnectAttribArray & attribs,
                    bool limit_iters,
                    exint iters,
                    UT_IntArray * prim_step_map = nullptr,
                    bool require_share_edge = false);

    // Grow a collection of points by N iterations
    static void     growPointGroupNIters(
                    GA_PointGroup & point_group,
                    const GEO_Detail & gdp,
                    const ConnectAttribArray & attribs,
                    bool limit_iters,
                    exint iters,
                    UT_IntArray * pt_step_map = nullptr);

    // Grow a collection of vertices by N iterations
    static void     growVertexGroupNIters(
                    GA_VertexGroup & vtx_group,
                    const GEO_Detail & gdp,
                    const ConnectAttribArray & attribs,
                    bool limit_iters,
                    exint iters,
                    UT_IntArray * vtx_step_map = nullptr);

    // Grow a collection of Edges by N iterations
    static void     growEdgeGroupNIters(
        GA_EdgeGroup & edge_group,
        const GEO_Detail & gdp,
        const ConnectAttribArray & attribs,
        bool limit_iters,
        exint iters,
        UT_IntArray * pt_step_map = nullptr);

    // The following interfaces allow providing 0 or 1 connectivity attributes.

    // Grow a collection of primitives by N iterations
    static void     growPrimGroupNIters(
                    GA_PrimitiveGroup & prim_group,
                    const GEO_Detail & gdp,
                    const GA_Attribute * attrib,
                    bool limit_iters,
                    exint iters,
                    UT_IntArray * prim_step_map = nullptr,
                    bool require_share_edge = false)
    {
        ConnectAttribArray con_arr;
        if (attrib)
            con_arr.append(attrib);

        growPrimGroupNIters(prim_group, gdp,
                con_arr, limit_iters, iters,
                prim_step_map, require_share_edge);
    }

    // Grow a collection of points by N iterations
    static void     growPointGroupNIters(
                    GA_PointGroup & point_group,
                    const GEO_Detail & gdp,
                    const GA_Attribute * attrib,
                    bool limit_iters,
                    exint iters,
                    UT_IntArray * pt_step_map = nullptr)
    {
        ConnectAttribArray con_arr;
        if (attrib)
            con_arr.append(attrib);

        growPointGroupNIters(point_group, gdp,
                con_arr, limit_iters, iters, pt_step_map);
    }

    // Grow a collection of vertices by N iterations
    static void     growVertexGroupNIters(
                    GA_VertexGroup & vtx_group,
                    const GEO_Detail & gdp,
                    const GA_Attribute * attrib,
                    bool limit_iters,
                    exint iters,
                    UT_IntArray * vtx_step_map = nullptr)
    {
        ConnectAttribArray con_arr;
        if (attrib)
            con_arr.append(attrib);

        growVertexGroupNIters(vtx_group, gdp,
                con_arr, limit_iters, iters, vtx_step_map);
    }

    // Grow a collection of Edges by N iterations
    static void     growEdgeGroupNIters(
        GA_EdgeGroup & edge_group,
        const GEO_Detail & gdp,
        const GA_Attribute * attrib,
        bool limit_iters,
        exint iters,
        UT_IntArray * pt_step_map = nullptr)
    {
        ConnectAttribArray con_arr;
        if (attrib)
            con_arr.append(attrib);

        growEdgeGroupNIters(edge_group, gdp,
                con_arr, limit_iters, iters, pt_step_map);
    }


    // The following functions will take in a seed group,
    // and expand the seed group to all connected geometry
    // ithin some curvature threshold specified by spread_angle
    // hidden_prims is a group of primitives to avoid extending to

    // group: the input group, this is the group that will be grown
    //          modifies the group to contain the grown group.
    // gdp: the detail
    // spread_angle: the maximum allowed angle between components when growing
    // limit_iters: if true will only grow a maximum of _iters_ iterations
    //               if false, will grow as far as possible
    // pick_all_matching_normals: if true, will ignore connectivity and
    //                            look at all components in the geometry.
    // static_reference_normal: if true, will compare normals of elements
    //                          to a single seed when growing the seed will
    //                          be picked as the first element in src_prims.
    // hidden_prims: a group of primitives to ignore
    // attrib: a connectivity attribute, if not nullptr, growth is
    //        contained to connected regions.
    //        If nullptr, connectivity is ignored.
    // normal_attr: the vector attribute to use as a normal
    static void         expandPrimsByNormal(
        GA_PrimitiveGroup & prim_group,
        const GEO_Detail & gdp,
        fpreal spread_angle,
        bool limit_iters,
        exint iters,
        bool pick_all_matching_normals,
        bool static_reference_normal,
        const GA_PrimitiveGroup * hidden_prims,
        const ConnectAttribArray & attribs,
        const GA_Attribute * normal_attr,
        UT_IntArray * prim_step_map = nullptr,
        bool require_share_edge = true);

    static void         expandPointsByNormal(
        GA_PointGroup & point_group,
        const GEO_Detail & gdp,
        fpreal spread_angle,
        bool limit_iters,
        exint iters,
        bool pick_all_matching_normals,
        bool static_reference_normal,
        const GA_PrimitiveGroup * hidden_prims,
        const ConnectAttribArray & attribs,
        const GA_Attribute * normal_attrib,
        UT_IntArray * pt_step_map = nullptr);

    static void         expandVerticesByNormal(
        GA_VertexGroup & vtx_group,
        const GEO_Detail & gdp,
        fpreal spread_angle,
        bool limit_iters,
        exint iters,
        bool pick_all_matching_normals,
        bool static_reference_normal,
        const GA_PrimitiveGroup * hidden_prims,
        const ConnectAttribArray & attribs,
        const GA_Attribute * normal_attrib,
        UT_IntArray * vtx_step_map = nullptr);

    static void         expandEdgesByNormal(
        GA_EdgeGroup & edge_group,
        const GEO_Detail & gdp,
        fpreal spread_angle,
        bool limit_iters,
        exint iters,
        bool pick_all_matching_normals,
        bool static_reference_normal,
        const GA_PrimitiveGroup * hidden_prims,
        const ConnectAttribArray & attribs,
        const GA_Attribute * normal_attrib,
        UT_IntArray * pt_step_map = nullptr);

    // Interfaces with only a uv_attribute
    static void         expandPrimsByNormal(
        GA_PrimitiveGroup & prim_group,
        const GEO_Detail & gdp,
        fpreal spread_angle,
        bool limit_iters,
        exint iters,
        bool pick_all_matching_normals,
        bool static_reference_normal,
        const GA_PrimitiveGroup * hidden_prims,
        const GA_Attribute * attrib, // Can be a uv_attribute, but other types are also accepted.
        const GA_Attribute * normal_attrib,
        UT_IntArray * prim_step_map = nullptr,
        bool require_share_edge = true)
    {
        ConnectAttribArray con_arr;
        if (attrib)
            con_arr.append(attrib);

        expandPrimsByNormal(prim_group, gdp, spread_angle, limit_iters, iters,
                            pick_all_matching_normals, static_reference_normal,
                            hidden_prims, con_arr, normal_attrib,
                            prim_step_map, require_share_edge);
    }

    static void         expandPointsByNormal(
        GA_PointGroup & point_group,
        const GEO_Detail & gdp,
        fpreal spread_angle,
        bool limit_iters,
        exint iters,
        bool pick_all_matching_normals,
        bool static_reference_normal,
        const GA_PrimitiveGroup * hidden_prims,
        const GA_Attribute * attrib,
        const GA_Attribute * normal_attrib,
        UT_IntArray * pt_step_map = nullptr)
    {
        ConnectAttribArray con_arr;
        if (attrib)
            con_arr.append(attrib);

        expandPointsByNormal(point_group, gdp, spread_angle, limit_iters, iters,
                            pick_all_matching_normals, static_reference_normal,
                            hidden_prims, con_arr, normal_attrib, pt_step_map);
    }

    static void         expandVerticesByNormal(
        GA_VertexGroup & vtx_group,
        const GEO_Detail & gdp,
        fpreal spread_angle,
        bool limit_iters,
        exint iters,
        bool pick_all_matching_normals,
        bool static_reference_normal,
        const GA_PrimitiveGroup * hidden_prims,
        const GA_Attribute * attrib,
        const GA_Attribute * normal_attrib,
        UT_IntArray * vtx_step_map = nullptr)
    {
        ConnectAttribArray con_arr;
        if (attrib)
            con_arr.append(attrib);

        expandVerticesByNormal(vtx_group, gdp, spread_angle, limit_iters, iters,
                            pick_all_matching_normals, static_reference_normal,
                            hidden_prims, con_arr, normal_attrib, vtx_step_map);
    }

    static void         expandEdgesByNormal(
        GA_EdgeGroup & edge_group,
        const GEO_Detail & gdp,
        fpreal spread_angle,
        bool limit_iters,
        exint iters,
        bool pick_all_matching_normals,
        bool static_reference_normal,
        const GA_PrimitiveGroup * hidden_prims,
        const GA_Attribute * attrib,
        const GA_Attribute * normal_attrib,
        UT_IntArray * pt_step_map = nullptr)
    {
        ConnectAttribArray con_arr;
        if (attrib)
            con_arr.append(attrib);

        expandEdgesByNormal(edge_group, gdp, spread_angle, limit_iters, iters,
                            pick_all_matching_normals, static_reference_normal,
                            hidden_prims, con_arr, normal_attrib, pt_step_map);
    }

    // Functions for shrinking collections of elements by N iterations
    // group: the group to shrink, these functions will modifty the
    //        group parm to contain the resultant after shrinking
    //  gdp: the detail
    //  attrib: an attribute specifying connectivity, if nullptr will
    //          not be used. If not nullptr, elements will shrink away
    //          from connectivity boundaries.
    //  iters: number of iterations to shrink
    static void     shrinkPrimGroupNIters(
        GA_PrimitiveGroup & prim_group,
        const GEO_Detail & gdp,
        const ConnectAttribArray & attribs,
        exint iters,
        UT_IntArray * prim_step_map = nullptr,
        bool require_share_edge = false);

    static void     shrinkPointGroupNIters(
        GA_PointGroup & point_group,
        const GEO_Detail & gdp,
        const ConnectAttribArray & attribs,
        exint iters,
        UT_IntArray * pt_step_map = nullptr);

    static void     shrinkVertexGroupNIters(
        GA_VertexGroup & vtx_group,
        const GEO_Detail & gdp,
        const ConnectAttribArray & attribs,
        exint iters,
        UT_IntArray * vtx_step_map = nullptr);

    static void     shrinkEdgeGroupNIters(
        GA_EdgeGroup & edge_group,
        const GEO_Detail & gdp,
        const ConnectAttribArray & attribs,
        exint iters,
        UT_IntArray * pt_step_map = nullptr);

    // The following provide interfaces for working with 0 or 1 attributes.

    static void     shrinkPrimGroupNIters(
        GA_PrimitiveGroup & prim_group,
        const GEO_Detail & gdp,
        const GA_Attribute * attrib,
        exint iters,
        UT_IntArray * prim_step_map = nullptr,
        bool require_share_edge = false)
    {
        ConnectAttribArray con_arr;
        if (attrib)
            con_arr.append(attrib);

        shrinkPrimGroupNIters(prim_group, gdp, con_arr, iters, prim_step_map, require_share_edge);
    }

    static void     shrinkPointGroupNIters(
        GA_PointGroup & point_group,
        const GEO_Detail & gdp,
        const GA_Attribute * attrib,
        exint iters,
        UT_IntArray * pt_step_map = nullptr)
    {
        ConnectAttribArray con_arr;
        if (attrib)
            con_arr.append(attrib);

        shrinkPointGroupNIters(point_group, gdp, con_arr, iters, pt_step_map);
    }

    static void     shrinkVertexGroupNIters(
        GA_VertexGroup & vtx_group,
        const GEO_Detail & gdp,
        const GA_Attribute * attrib,
        exint iters,
        UT_IntArray * vtx_step_map = nullptr)
    {
        ConnectAttribArray con_arr;
        if (attrib)
            con_arr.append(attrib);

        shrinkVertexGroupNIters(vtx_group, gdp, con_arr, iters, vtx_step_map);
    }

    static void     shrinkEdgeGroupNIters(
        GA_EdgeGroup & edge_group,
        const GEO_Detail & gdp,
        const GA_Attribute * attrib,
        exint iters,
        UT_IntArray * pt_step_map = nullptr)
    {
        ConnectAttribArray con_arr;
        if (attrib)
            con_arr.append(attrib);

        shrinkEdgeGroupNIters(edge_group, gdp, con_arr, iters, pt_step_map);
    }


    // Functions for finding the boundary.
    // group: the group of which to find the boundary, these functions will
    //        modify the group parameter to contain the resultant boundary.
    // gdp: the detail that the group is on.
    // attrib: a connectivity attribute specifying connected regions of
    //         geometry will not be used if nullptr.
    static void     findPrimGroupBoundary(
        GA_PrimitiveGroup & prim_group,
        const GEO_Detail & gdp,
        const ConnectAttribArray & attribs,
        bool consider_unshared_edges = true,
        bool all_pt_boundary = false,
        bool consider_unshared_curve_edges = true);

    static void     findPointGroupBoundary(
        GA_PointGroup & pt_group,
        const GEO_Detail & gdp,
        const ConnectAttribArray & attribs,
        bool consider_unshared_edges = true,
        bool consider_unshared_curve_edges = true);

    static void     findVertexGroupBoundary(
        GA_VertexGroup &        vtx_group,
        const GEO_Detail & gdp,
        const ConnectAttribArray & attribs,
        bool consider_unshared_edges = true,
        bool consider_unshared_curve_edges = true);

    static void     findEdgeGroupBoundary(
        GA_EdgeGroup &  edge_group,
        const GEO_Detail & gdp,
        const ConnectAttribArray & attribs,
        bool consider_unshared_edges = true,
        bool consider_unshared_curve_edges = true);

    // The following provide interfaces for working with 0 or 1 attributes.

    static void     findPrimGroupBoundary(
        GA_PrimitiveGroup & prim_group,
        const GEO_Detail & gdp,
        const GA_Attribute * attrib,
        bool consider_unshared_edges = true,
        bool all_pt_boundary = false,
        bool consider_unshared_curve_edges = true)
    {
        ConnectAttribArray con_arr;
        if (attrib)
            con_arr.append(attrib);

        findPrimGroupBoundary(prim_group, gdp, con_arr,
                    consider_unshared_edges, all_pt_boundary,
                    consider_unshared_curve_edges);
    }

    static void     findPointGroupBoundary(
        GA_PointGroup & pt_group,
        const GEO_Detail & gdp,
        const GA_Attribute * attrib,
        bool consider_unshared_edges = true,
        bool consider_unshared_curve_edges = true)
    {
        ConnectAttribArray con_arr;
        if (attrib)
            con_arr.append(attrib);

        findPointGroupBoundary(pt_group, gdp, con_arr,
                    consider_unshared_edges,
                    consider_unshared_curve_edges);
    }

    static void     findVertexGroupBoundary(
        GA_VertexGroup & vtx_group,
        const GEO_Detail & gdp,
        const GA_Attribute * attrib,
        bool consider_unshared_edges = true,
        bool consider_unshared_curve_edges = true)
    {
        ConnectAttribArray con_arr;
        if (attrib)
            con_arr.append(attrib);

        findVertexGroupBoundary(vtx_group, gdp, con_arr,
                    consider_unshared_edges,
                    consider_unshared_curve_edges);
    }

    static void     findEdgeGroupBoundary(
        GA_EdgeGroup & edge_group,
        const GEO_Detail & gdp,
        const GA_Attribute * attrib,
        bool consider_unshared_edges = true,
        bool consider_unshared_curve_edges = true)
    {
        ConnectAttribArray con_arr;
        if (attrib)
            con_arr.append(attrib);

        findEdgeGroupBoundary(edge_group, gdp, con_arr,
                    consider_unshared_edges,
                    consider_unshared_curve_edges);
    }
};

#endif