GU_Classify.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_Classify.h ( GU Library, C++)
*
* COMMENTS:
*      Useful functions for classifying components by various criteria.
*/

#ifndef __GU_Classify_h__
#define __GU_Classify_h__

#include "GU_API.h"

#include <UT/UT_VectorTypes.h>
#include <UT/UT_Map.h>
#include <GA/GA_Types.h>
#include <GA/GA_Edge.h>
#include <GA/GA_Breakpoint.h>

class UT_Classifier;
class GA_Primitive;
class GA_Range;
class GA_PointGroup;
class GA_PrimitiveGroup;
class GA_EdgeGroup;
class GA_BreakpointGroup;
class GEO_Detail;

namespace GU_Classify
{

    /// Classify primitives by shared point references, so two primitives will
    /// be in the same class iff they both reference a common point.
    ///
    /// point_closure is optional
    GU_API void  classifyPrimsBySharedPoints(
                                const GEO_Detail &gdp,
                                const GA_PrimitiveGroup *prim_group,
                                const GA_PointGroup *point_closure,
                                const UT_Map<GA_Offset, exint> &class_map,
                                UT_Classifier &prim_classifier);

    /// Partition a group of primitives (or all primitives if no group is given)
    /// into a single array that groups all primitives classified to the same
    /// class together.  Both the classes and the member primitives in each are
    /// in the order encountered by a standard traversal.
    ///
    /// The class_start_indices array is set to contain the start index into
    /// the class_prims for each class, plus an extra entry containing the
    /// number of entries of class_prims.
    GU_API void  partitionPrimsBySharedPoints(
                                const GEO_Detail &gdp,
                                const GA_PrimitiveGroup *prim_group,
                                GA_OffsetArray &class_prims,
                                UT_ExintArray &class_start_indices);

    /// Classify points by shared primitive references, so two points will be
    /// in the same class iff they are both referenced by a common primitive.
    ///
    /// candidate_prims is optional
    GU_API void  classifyPointsBySharedPrims(
                                const GEO_Detail &gdp,
                                const GA_PointGroup *point_group,
                                const GA_PrimitiveGroup *candidate_prims,
                                const UT_Map<GA_Offset, exint> &class_map,
                                UT_Classifier &point_classifier);

    /// Classify points by edge connectivity, so two points will be in the
    /// same class iff they are connected by an edge.
    ///
    /// prim_closure is optional
    GU_API void  classifyPointsByEdgeConnectivity(
                                const GEO_Detail &gdp,
                                const GA_PointGroup *point_group,
                                const GA_PrimitiveGroup *prim_closure,
                                const UT_Map<GA_Offset, exint> &class_map,
                                UT_Classifier &point_classifier);
    /// Classify points by edge connectivity, so two points will be in the
    /// same class iff they are connected by an edge.
    ///
    /// Class map is optional.  If not present, the point indices are used.
    GU_API void  classifyPointsByEdgeConnectivity(
                                const GEO_Detail &gdp,
                                const UT_Map<GA_Offset, exint> *class_map,
                                UT_Classifier &point_classifier);

    /// Partition a group of points (or all points if no group is given)
    /// into a single array that groups all primitives classified to the same
    /// class together.  Both the classes and the member points in each are
    /// in the order encountered by a standard traversal.
    ///
    /// The class_start_indices array is set to contain the start index into
    /// the class_points for each class, plus an extra entry containing the
    /// number of entries of class_points.
    GU_API void  partitionPointsByEdgeConnectivity(
                                const GEO_Detail &gdp,
                                const GA_PointGroup *point_group,
                                const GA_PrimitiveGroup *prim_closure,
                                GA_OffsetArray &class_points,
                                UT_ExintArray &class_start_indices);

    /// Partition a group of edges into a single array that groups all edges
    /// classified to the same class together.  Both the classes and the member
    /// edges in each are in the order encountered by a standard traversal.
    ///
    /// The class_start_indices array is set to contain the start index into
    /// the class_edges for each class, plus an extra entry containing the
    /// number of entries of class_edges.
    GU_API void  partitionEdgesByConnectivity(
                                const GEO_Detail &gdp,
                                const GA_EdgeGroup &edge_group,
                                UT_Array<GA_Edge> &class_edges,
                                UT_ExintArray &class_start_indices);

    /// Partition a group of breakpoints (or all breakpoints if no group is
    /// given) into a single array that groups all breakpoints classified to
    /// the same class together.  Both the classes and the member breakpoints
    /// in each are in the order encountered by a standard traversal.
    ///
    /// The class_start_indices array is set to contain the start index into
    /// the class_bkpts for each class, plus an extra entry containing the
    /// number of entries of class_bkpts.
    GU_API void  partitionBreakpointsBySpline(
                                const GEO_Detail &gdp,
                                const GA_BreakpointGroup *bkpt_group,
                                UT_Array<GA_Breakpoint> &class_bkpts,
                                UT_ExintArray &class_start_indices);
}

#endif // __GU_Classify_h__