PK_blend_limit_data_t

struct PK_blend_limit_data_s
    {
    int                          n_limits;         --- number of limits (0)
    const PK_VECTOR_t           *limit_points;     --- limit points (NULL)
    const PK_VECTOR_t           *limit_directions; --- limit directions (NULL)
    const PK_EDGE_t             *edges;            --- edges (NULL)
    const PK_blend_limit_type_t *limit_types;      --- limit types (NULL) [PF]
    const PK_blend_limit_patch_t
                                *limit_patch;      --- controls whether to try
                                                   --- patching the blend
                                                   --- beyond the supplied
                                                   --- limits (NULL) [NF]
    int                          n_vertices;       --- number of vertices (0)
    const PK_VERTEX_t           *vertices;         --- vertices (NULL) [NF]
    };
typedef struct PK_blend_limit_data_s PK_blend_limit_data_t;




This structure records information which specifies limits for the blend.

Used in:

PK_BODY_fix_blends_o_t

There are three different ways of constraining a blend using this structure;
limits can be applied to edges, overlapping regions and vertices.

                        Blend Limit Options:

'limit_points'     is an array of length 'n_limits' of points that specify the
                   position of the limits of the blend.  If the associated
                   limit type is PK_blend_limit_type_edge_c, this position
                   will be the closest point on the blend spine to the location
                   provided.  If the associated limit type is
                   PK_blend_limit_type_overlap_c, the position specifies an
                   overlap limit.  For limits of type
                   PK_blend_limit_type_edge_c set on facet geometry, or for
                   any limit of type PK_blend_limit_type_overlap_c, the
                   position is required to lie on the associated edge from
                   the 'edges' array.

'limit_directions' is an array of length 'n_limits' specifying which direction
                   the blend will lie in with respect to its associated limit
                   point. If the associated limit type is
                   PK_blend_limit_type_overlap_c this direction is ignored,
                   but must be given so that the lengths of the 'limit_points',
                   'limit_directions' and 'limit_types' arrays are consistent.

'edges'            is an array of length 'n_limits' specifying which edges of
                   the blend shall have a limit applied.

'limit_types'      is an array of length 'n_limits' specifying whether the
                   points in the 'limit_points' array designate edge limits
                   or overlap limits.

                   Note: Only limits of the type PK_blend_limit_type_edge_c are
                   currently supported when fixing blends on facet geometry.

'limit_patch'      is an array of length 'n_limits' specifying whether to try
                   patching the blend beyond the limits specified in the
                   'limit_points' array.

'vertices'         is an array of length 'n_vertices' specifying which vertices
                   of the blend shall have a limit applied. Limit vertices do
                   not require 'limit_points' or 'limit_directions'. The limits
                   of the blend are defined by the intersection of the adjacent
                   blend boundaries.


Limits are applied to edges using 'limit_points', 'limit_directions', and
'edges'. The blend will stop at an isoparameter at the closest point on the
blend spine to each supplied limit point. The blend will lie on the side of
the isoparameter indicated by its corresponding limit direction. Restrictions
when applying edge limits include:
-   Only blends that lie in the direction of the limit will be applied.
-   If no corresponding point on the blend spine can be found for a supplied
    limit point a fault will be returned.
-   There is a maximum of two limits per edge.
-   Limits may not be applied to a mixed edge.

Limits are applied to overlapping regions using 'limit_points' and 'edges'
(the value of the 'limit_direction' associated with the 'limit_point'
specifying  the overlap limit is ignored). The blend will stop at an
isoparameter where it would overlap another blend fixed in the same call.
If there is more than one such overlap region, the blend will be stopped at
the region closest to the location specified in 'limit_points'. If there is
no suitable overlap region on the chain of blended edges the point lies on,
fixing the blend will fail with PK_blend_fault_bad_cap_c.

Limits are applied to vertices using 'vertices'. Here, limit points are defined
internally by the intersections of adjacent blend boundaries. Vertex limits can
only be applied to vertices which have at least three edges.

If the edge limits or overlap limits on an edge at a vertex limit are
combined with the limits imposed on the edge by the vertex limit, the result
is equivalent to the result when blends with the respective limits are
applied consecutively, the vertex limit blend being applied first, followed by
the edge limit and finally the overlap limit.

See Creating blend limits for more information.