PK_FACE_spin

PK_ERROR_code_t         PK_FACE_spin
(
--- received arguments ---
int                     n_faces,       --- number of faces
const PK_FACE_t         faces[],       --- faces
const PK_AXIS1_sf_t    *axis,          --- spin axis
double                  angle,         --- spin angle
PK_LOGICAL_t            local_check,   --- whether local checking will be done

--- returned arguments ---
int              *const n_laterals,    --- number of laterals
PK_FACE_t       **const laterals,      --- new faces (may be NULL)
PK_EDGE_t       **const bases,         --- edges swept into laterals
                                       --- (may be NULL)
PK_local_check_t *const check_result   --- result of local check
)


This function spins one or more faces of a solid or sheet body.

This function does not support facet geometry [NF]


Specific Errors:
    PK_ERROR_unsuitable_entity     Face(s) unsuitable for spin
    PK_ERROR_wrong_entity          Bad arguments
    PK_ERROR_bad_angle             bad angle
    PK_ERROR_non_manifold          Can't spin face with non-manifold boundary
    PK_ERROR_impossible_spin       Can't determine spun geometry
    PK_ERROR_su_self_intersect     Spin would produce a self intersecting surf


The face(s) to be spun are moved along an arc specified by the axis leaving
lateral entities in its wake.

See Local Ops: Spinning or Sweeping an Entity for more information.

Faces which may be spun, the laterals they produce and the type of the
resulting body are identified in the following table.



    Spun Bodies           |         Laterals         |       Result
===========================================================================
One or more faces of a    |   One or more faces      |      Solid body
solid body                |                          |
One or more faces of a    |   One or more faces      |      Sheet body
sheet body                |                          |
============================================================================

For every entry in 'laterals', there is a corresponding entry in 'bases'. This
array contains the topological entities extruded to create the lateral entities
For every lateral face there is a spun edge from the original body and for
every lateral edge there is a spun vertex.



Suitable Spin Entities:

   . Any group of manifold faces of a solid or sheet body. Entire shells must
     not be contained within the list

Attempting to spin a face which is not one of the above will give rise
to one of PK_ERROR_wrong_entity, PK_ERROR_unsuitable_entity or
PK_ERROR_non_manifold as appropriate.



Permissible Spins:

   . An entity may not be spun through more than 2pi or less than -2pi.
     It is not possible to perform full spins (where the angle is 2pi or
     -2pi) on faces of a solid or sheet.

A face which has an edge whose attached curve is of the class PK_CLASS_fcurve
(i.e. foreign geometry) or class PK_CLASS_cpcurve (i.e. constant parameter
curve) cannot be spun.

After a spin any coincident topology will not be fused or united.

In general this procedure may give rise to self-intersecting body
boundaries, which could cause unpredictable errors later.

Any new surfaces created are analytic surfaces if possible. If it is
not possible to use an analytic surface then the class of the new
surface will be PK_CLASS_spun or PK_CLASS_bsurf depending upon the most
recent call to PK_SESSION_set_swept_spun_surfs.

If local checking is switched on ('local_check' = PK_LOGICAL_true), consistency
checks will be made on newly created topological and geometrical
entities, and the result of the check returned.
A result of PK_local_check_ok_c indicates the body is valid. A result
of PK_local_check_negated_c indicates that the result body was originally
"inside out" but has been negated, and is now "positive" (has positive volume)
and valid. A result of PK_local_check_failed_c indicates the body
is self-intersecting and further modelling operations on it may fail.

If 'local_check' is PK_LOGICAL_false, local checking will be switched off and
the result returned will be PK_local_check_no_c.

A self-intersecting body can be returned.