PK_ERROR_code_t              PK_BODY_taper
(
--- received arguments ---
const PK_BODY_t              body,           --- body to be tapered
int                          n_refs_above,   --- number of reference
                                             --- entities above parting
                                             --- sheet
const PK_ENTITY_t            refs_above[],   --- reference entities
                                             --- above parting sheet
int                          n_refs_below,   --- number of reference
                                             --- entities below parting
                                             --- sheet
const PK_ENTITY_t            refs_below[],   --- reference entities
                                             --- below parting sheet
const PK_BODY_t              parting_body,   --- parting body
PK_VECTOR1_t                 direction,      --- draw direction
double                       angle_above,    --- taper angle above
double                       angle_below,    --- taper angle below
const PK_BODY_taper_o_t     *options,        --- options

--- returned arguments ---
PK_TOPOL_track_r_t    *const tracking,       --- tracking information
PK_TOPOL_local_r_t    *const results         --- status information
)


This function applies two-sided tapering to the body parted
by the parting_body.


Specific Errors:
    PK_ERROR_unsuitable_topology    only solid bodies and solid
                                    or sheet parting bodies are
                                    supported (MILD)

    PK_ERROR_wrong_entity_in_array  given references are not from
                                    same body or non-default tapering
                                    method entities not given as
                                    references (MILD)

    PK_ERROR_bad_reference          invalid reference entity (MILD)

    PK_ERROR_impossible_taper       taper conditions cannot be
                                    satisfied (SERIOUS)

    PK_ERROR_not_implemented        unavailable functionality is
                                    called (MILD)

    PK_ERROR_taper_failed           PK_BODY_taper suffered an
                                    internal algorithmic failure
                                    (SERIOUS)



The body is divided by the parting_body into "above" and "below"
halves with respect to the draw direction. Taper faces are then
constructed and replace existing faces between given references on
each half and the parting_body.

Surfaces of new taper faces are defined by the direction and
angle_above or angle_below for "above" and "below" halves
respectively. These surfaces originate at refs_above and refs_below
and propagate to the intersection with the parting_body.

Currently only edge references forming a single chain on either
side are supported.

Default tapering method can be defined for all references with
default_method option field. It is possible to override the default
method for each reference entity using methods and method_refs
arrays of the option structure.

If resulting tapered faces from two halves do not meet at the
parting_body then  the function will do the following depending on
miter_at_parting option field:

Non-mitered solution (miter_at_parting is PK_LOGICAL_false)

Any gaps between misaligned "above" and "below" halves at the
parting_body will be filled using faces of the parting_body.

Mitered solution (miter_at_parting is PK_LOGICAL_true)

Extra material will be added to one or both halves to make sure
they match at the parting_body. This results in increased
taper angle for some of the new faces.

The function allows for one-sided solutions. In this case only one
set of references should be given and a parting_body must be the same
as the body. The function will construct new taper surfaces from
the given references to the intersection with the body.

For further details regarding this method of tapering please refer
to the Parasolid Functional Description Chapter Body Tapering.