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 body.


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. 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                |                          |
============================================================================

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 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.

A face which has an edge whose attached curve is of the class PK_CLASS_icurve,
(ie intersection curve), PK_CLASS_fcurve (ie foreign geometry),
PK_CLASS_spcurve (ie sp-curve) or class PK_CLASS_cpcurve (ie constant parameter
curve) cannot be spun. However, tolerant edges which have curves of class
PK_CLASS_spcurve (ie sp-curves) attached to their fins can 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.