Syntax Summary

Syntax Summary

PART_CONTEXT* active_part_context();

void add_rbase_app_cb( rbase_app_callback* cb);

logical af_delete_facets( ENTITY* entity);

void af_delete_mesh( ENTITY* entity);

double angle_between(const SPAunit_vector& v1, const
SPAunit_vector& v2, const SPAunit_vector& z
=*(SPAunit_vector*)NULL_REF);

logical antiparallel( SPAunit_vector const& v1,
SPAunit_vector const& v2, const double res= SPAresnor);

outcome api_abh_chamfer_edges(const ENTITY_LIST& edgs,
double r1, double r2= -1, double r1_end= -1, double r2_end= -1,
double R1= 0, double R2= 0, AcisOptions* ao = NULL);

outcome api_abh_edge_project( BODY* b, EDGE* e, logical
sequence, double dist, logical left, SPAvector v, AcisOptions* ao =
NULL);

outcome api_abh_imprint( BODY* int_wire, ENTITY_LIST&
edge_list, AcisOptions* ao= NULL);

outcome api_abh_slice( BODY* tool, BODY* blank,
BODY*& int_wire, AcisOptions* ao = NULL);

outcome api_abh_vblend( EDGE* in_ed, double r1, double r2,
AcisOptions* ao = NULL);

outcome api_abort_state( HISTORY_STREAM* hs= NULL);

outcome api_accurate_bs3_approximation( FACE* face, double
requested_tol, bs3_surface& fit_sur=*(bs3_surface*)NULL_REF,
AcisOptions* ao = NULL);

outcome api_add_generic_named_attribute( ENTITY* ent, const
    char* name, ENTITY* value, split_action split_opt= SplitKeep,
    merge_action merge_opt= MergeKeepKept, trans_action trans_opt=
    TransIgnore, copy_action copy_opt= CopyCopy, AcisOptions* ao = NULL
    );

outcome api_add_guide_curve_si( AcisSLInterface* obj,
EDGE* in_guide, AcisOptions* opts = NULL);

outcome api_add_mapping_curve_sli( AcisSLInterface* obj, int
num, SPAposition* pts, AcisOptions* opts = NULL);

outcome api_add_state( DELTA_STATE* ds, HISTORY_STREAM*
hs);

outcome api_add_vertex_sli( AcisSLInterface* obj, WIRE*
wire, COEDGE* coedge, AcisOptions* opts = NULL);

outcome api_advanced_cover( FACE* target_face,
acover_options* options= NULL, AcisOptions* opts= NULL);

outcome api_align_wires_sli( AcisSLInterface* obj, int start
= 0, int end = 0, AcisOptions* opts = NULL);

outcome api_alternating_keep_pattern( pattern*& pat,
const pattern& in_pattern, logical keep1, logical keep2, int
which_dim, logical merge = TRUE, AcisOptions* ao = NULL);

outcome api_alternating_scale_pattern( pattern*& pat,
    const pattern& in_pattern, double scale1, double scale2, int
    which_dim, const SPAposition& root, logical merge = TRUE,
    AcisOptions* ao = NULL);

outcome api_apply_transf( ENTITY* entity, SPAtransf
const& trans, AcisOptions* ao = NULL);

void api_bb_begin(logical linear= TRUE);

void api_bb_delete();

void api_bb_end( outcome& result, logical linear= TRUE,
logical delete_stacked_bb = FALSE);

outcome api_bend_entity( ENTITY* in_entity, SPAposition&
    neutral_root, SPAunit_vector&neutral_axis, SPAunit_vector&
    bend_direction, double radius, double angle, double width= -1, logical
    f_center_bend= FALSE, int n_points= 0, SPAposition* bend_regions
    = NULL, AcisOptions* opts = NULL);

outcome api_bend_to_curve_entity( BODY* in_entity, const
    SPAposition& start, const SPAposition& end, const SPAunit_vector&
    initial_rail, curve_law* final_curve, law* final_rail = NULL,
    AcisOptions* opts = NULL);

outcome api_blend_edges( ENTITY_LIST& edges, double radius,
AcisOptions* ao= NULL);

outcome api_blend_edges_pos_rad(const ENTITY_LIST& eds,
    const int num_fixes, SPAposition fix_positions[], double
    fix_radii[], double* start_slope= NULL, double* end_slope =
    NULL, AcisOptions* ao = NULL);

outcome api_blend_graph( ENTITY* this_ent, ENTITY_LIST&
ent_list, AcisOptions* ao= NULL);

outcome api_blend_seq( EDGE* this_edge, ENTITY_LIST&
ents, AcisOptions* ao= NULL);

outcome api_body( BODY*& bodyOut, AcisOptions* ao
= NULL);

outcome api_body_mass_pr( BODY* body, SPAposition const&
    root_proj_pl, SPAunit_vector const&normal_proj_pl, int selector, double
    req_rel_accy, double& volume, SPAposition& cofg, tensor& inertia,
    double p_moments[], SPAunit_vector p_axes[],
    double& est_rel_accy_achieved, double sheet_thickness = 0.0,
    AcisOptions* ao = NULL);

outcome api_body_to_2d( BODY* body, AcisOptions* ao =
NULL);

outcome api_boolean( BODY* tool, BODY* blank, BOOL_TYPE op,
    NDBOOL_KEEP ndbool_keep= NDBOOL_KEEP_NEITHER, BODY*&
    result_body=*(BODY**)NULL_REF, AcisOptions* ao =
    NULL);

outcome api_boolean_chop_body( BODY* tool, BODY* blank,
    logical nonreg, BODY*& outside, BODY*& leftovers
    =*(BODY**)NULL_REF, NDBOOL_KEEP ndbool_keep= NDBOOL_KEEP_NEITHER,
    BODY*& result_body=*(BODY**)NULL_REF,
    AcisOptions* ao = NULL);

outcome api_boolean_chop_complete(logical nonreg,
    BODY*& outside, BODY*& leftovers
    =*(BODY**)NULL_REF, NDBOOL_KEEP ndbool_keep= NDBOOL_KEEP_NEITHER,
    BODY*& result_body=*(BODY**)NULL_REF,
    AcisOptions* ao= NULL);

outcome api_boolean_complete( BOOL_TYPE op, NDBOOL_KEEP
ndbool_keep = NDBOOL_KEEP_NEITHER, BODY*& res
=*(BODY**)NULL_REF, AcisOptions* ao = NULL);

outcome api_boolean_glue( BODY* tool, BODY* blank,
    BOOL_TYPE op, const glue_options* glue_opts, NDBOOL_KEEP ndbool_keep
    = NDBOOL_KEEP_NEITHER, BODY*& result_body
    =*(BODY**)NULL_REF, AcisOptions* ao = NULL);

outcome api_boolean_start( BODY* tool, BODY* blank,
AcisOptions* ao = NULL);

outcome api_boolean_tube_body( BODY* blank, BODY* tube,
    ENTITY_LIST& start_faces, ENTITY_LIST& end_faces, SPAposition*
    start_pos, int number_of_starts, SPAposition* end_pos, int
    number_of_ends, SPAvector start_dir, tube_options** opts, int
    number_of_options, ENTITY_LIST& bodies, AcisOptions* ao = NULL);

outcome api_bool_make_intersection_graph( BODY* tool,
BODY* blank, BODY*& graph, BOOL_TYPE type= UNION, const
glue_options* glue_opts= NULL, AcisOptions* ao= NULL);

outcome api_breakup_wires_sli( AcisSLInterface* obj, int
start = 0, int end = 0, AcisOptions* opts = NULL);

outcome api_build_body_sli( AcisSLInterface* obj,
BODY*& body_out, AcisOptions* opts = NULL);

outcome api_build_edges_sli( AcisSLInterface* obj,
ENTITY_LIST& edgeList, AcisOptions* opts = NULL);

outcome api_build_faces_sli( AcisSLInterface* obj,
ENTITY_LIST& edgeList, AcisOptions* opts = NULL);

outcome api_build_wire( BODY* given_body, logical closed, int
length, SPAposition points[], curve* curves[],
BODY*& body, AcisOptions* ao = NULL);

outcome api_calculate_edge_tolerance( EDGE* edge,
double& tol, AcisOptions* ao = NULL);

outcome api_calculate_vertex_tolerance( VERTEX* vertex,
double& tol, AcisOptions* ao = NULL);

outcome api_chamfer_edges( ENTITY_LIST& edges, double
left_range, double right_range= -1, AcisOptions* ao= NULL);

outcome api_chamfer_vertex( VERTEX* vertex, double offset1,
    EDGE* edge1= NULL, double offset2= -1, EDGE* edge2= NULL,
    double offset3= -1, EDGE* edge3= NULL, logical
    distanceStraight= TRUE, AcisOptions* ao= NULL);

outcome api_chamfer_vertices( ENTITY_LIST& vertices, double
offset, logical distanceStraight= TRUE, AcisOptions* ao= NULL
);

outcome api_change_body_trans( BODY* body, TRANSFORM*
new_transform, logical negate = FALSE, AcisOptions* ao = NULL);

outcome api_change_state( DELTA_STATE* ds);

outcome api_change_to_state( HISTORY_STREAM* hs,
DELTA_STATE* ds, int& n_actual);

outcome api_checking(logical on_off);

outcome api_check_ct(const ENTITY* ent,
insanity_list*& list, AcisOptions* ao = NULL);

outcome api_check_cur_smoothness( EDGE* given_edge,
curve_irregularities*& cirr, int& no_pts, AcisOptions* ao = NULL);

outcome api_check_edge( EDGE* edge,
check_status_list*& list, AcisOptions* ao = NULL);

outcome api_check_edge_errors( ENTITY_LIST const& edges,
    ENTITY_LIST& bad_edges, ENTITY*& worst_entity, double&
    worst_error, double tol= SPAresabs, logical stop_immediately= FALSE,
    ENTITY_LIST& new_edges=*(ENTITY_LIST*)NULL_REF,
    AcisOptions* ao = NULL);

outcome api_check_entity(const ENTITY* given_entity,
insanity_list*& list, AcisOptions* ao = NULL);

outcome api_check_entity_ff_ints(const ENTITY*
    given_entity, ENTITY_LIST* insane_ents, logical& bad_ints, FILE*
    file_ptr= NULL, insanity_list*& list
    =*(insanity_list**)NULL_REF, AcisOptions* ao = NULL);

outcome api_check_face( FACE* face,
check_status_list*& list, AcisOptions* ao = NULL);

outcome api_check_face_clearance( FACE* face1, FACE*
    face2, double min_clearance, double facet_resolution, SPAposition&
    p1, SPAposition& p2, double& min_dist, AcisOptions* ao
    = NULL);

outcome api_check_face_loops( FACE* in_face, int
ai_info[]= NULL, AcisOptions* ao = NULL);

outcome api_check_histories( HISTORY_STREAM_LIST*
insane_list= NULL, FILE* fptr= stdout);

outcome api_check_list_ff_ints(int num_faces1, FACE*
    face_list1[], ENTITY_LIST* insane_ents, logical& bad_ints, FILE*
    file_ptr= NULL, int num_faces2= 0, FACE* face_list2[]
    = NULL, AcisOptions* ao = NULL);

logical api_check_on();

outcome api_check_solid_clearance( BODY* user_body1,
    BODY* user_body2, double min_clearance, double facet_resolution,
    SPAposition& p1, SPAposition& p2, double& min_dist, AcisOptions* ao
    = NULL);

outcome api_check_vertex_errors( ENTITY_LIST const&
    vertices, ENTITY_LIST& bad_vertices, ENTITY*& worst_entity,
    double& worst_error, double tol= SPAresabs, logical stop_immediately
    = FALSE, ENTITY_LIST& new_vertices
    =*(ENTITY_LIST*)NULL_REF, AcisOptions* ao = NULL);

outcome api_check_wire_self_inters( BODY* body,
AcisOptions* ao = NULL);

outcome api_clean_body( BODY* body, AcisOptions* ao =
NULL);

outcome api_clean_entity( ENTITY* ent, AcisOptions* ao
= NULL);

outcome api_clean_wire( BODY* wire, AcisOptions* ao =
NULL);

outcome api_clear_annotations( AcisOptions* ao = NULL);

outcome api_clear_guide_curves_sli( AcisSkinningInterface*
obj, AcisOptions* opts = NULL);

outcome api_clear_mapping_curves_sli( AcisSLInterface* obj,
AcisOptions* opts = NULL);

outcome api_closed_wire( BODY* body, AcisOptions* ao =
NULL);

outcome api_collapse_wires_sli( AcisSLInterface* obj,
ENTITY_LIST& wire_list, AcisOptions* opts = NULL);

outcome api_combine_body( BODY* from_body, BODY* to_body,
AcisOptions* ao = NULL);

outcome api_combine_edges( EDGE* edge1, EDGE* edge2,
EDGE*& new_edge, FILE* outfile= NULL, AcisOptions* ao =
NULL);

outcome api_complete_blends( BODY* int_graph, BODY*
sheet, BODY* this_body, AcisOptions* ao= NULL);

outcome api_complete_intersection_graph( BODY* tbody,
BODY* blank, BODY*& graph, AcisOptions* ao= NULL);

outcome api_concl_blend_ss( blend1_data& bl1_data, BODY*
sheet_body, AcisOptions* ao= NULL);

outcome api_convert_pipes(int const nface, FACE*
face[], AcisOptions* ao = NULL);

outcome api_convert_to_spline( ENTITY* given_entity,
ENTITY*& return_entity, AcisOptions* ao = NULL);

outcome api_copy_body( BODY* body, BODY*& new_body,
AcisOptions* ao = NULL);

outcome api_copy_entity( ENTITY* entity, ENTITY*&
new_entity, AcisOptions* ao = NULL);

outcome api_copy_entity_contents( ENTITY* in_ent,
ENTITY*& copy, SPAtransf& tr=*(SPAtransf*)NULL_REF,
AcisOptions* ao = NULL);

outcome api_copy_entity_list( ENTITY_LIST& entity_list,
ENTITY_LIST& copied_entity_list, AcisOptions* ao = NULL);

outcome api_cover_circuits(int num_circuits, ENTITY_LIST*
array_circuits[], surface const& surf, ENTITY_LIST& faces_list,
AcisOptions* ao = NULL);

outcome api_cover_planar_edges( ENTITY_LIST& eds,
BODY*& out_bdy, ENTITY_LIST& wires, int nest= TRUE,
AcisOptions* ao = NULL);

outcome api_cover_planar_wires( ENTITY_LIST& wbs,
BODY*& out_bdy, ENTITY_LIST& out_wires, logical nest,
AcisOptions* ao);

outcome api_cover_sheet( BODY* sheet, surface const& surf,
ENTITY_LIST& faces_list, logical multiple_cover = FALSE, AcisOptions*
ao = NULL);

outcome api_cover_wire( WIRE* wire, surface const& surf,
FACE*& face, AcisOptions* ao = NULL);

outcome api_cover_wires( BODY* wire_body, surface const&
surf, ENTITY_LIST& faces_list, AcisOptions* ao = NULL);

outcome api_cover_wire_loops( ENTITY_LIST& wires,
BODY*& sheet, AcisOptions* ao = NULL);

outcome api_create_boundary_field( ENTITY_LIST& coeds,
    FACE** ref_faces, fieldtype ftype, int rev, double draft, SPAvector&
    uniform_vec, ENTITY_LIST& cons_eds, int global, law**
    out_law&, AcisOptions* ao = NULL);

outcome api_create_graph_from_cells( ENTITY_LIST& cells,
generic_graph*& graph, AcisOptions* ao = NULL);

outcome api_create_graph_from_edges( ENTITY_LIST& edges,
generic_graph*& graph, AcisOptions* ao = NULL);

outcome api_create_graph_from_faces( ENTITY_LIST& faces,
generic_graph*& graph, AcisOptions* ao = NULL);

outcome api_create_history( HISTORY_STREAM*& hs);

outcome api_create_li(int number_coedges,
    Loft_Connected_Coedge_List* edgeList, AcisLoftingInterface*& obj,
    BODY**& wireBodies, skin_options* opts, AcisOptions* ao= NULL
    );

outcome api_create_point(const SPAposition& pos,
APOINT*& pnt, AcisOptions* ao = NULL);

outcome api_create_refinement( REFINEMENT*& ref,
AcisOptions* ao = NULL);

outcome api_create_si( ENTITY_LIST&,
AcisSkinningInterface*&, BODY**& wireBodies, BODY* path = NULL,
skin_options* opts, AcisOptions* opts= NULL);

outcome api_create_text(const SPAposition& location, const
char* string, const char* font, int size, TEXT_ENT*& text,
AcisOptions* ao = NULL);

outcome api_create_vertex_template(int n_tokens, int
tokens[], VERTEX_TEMPLATE*& tplate, AcisOptions* ao = NULL
);

outcome api_crv_self_inters( CURVE* crv, double start_par,
double end_par, curve_curve_int*&self_intersection,
AcisOptions* ao = NULL);

outcome api_ct_add_to_group( ENTITY* ent, SPAGROUP*
group, AcisOptions* ao = NULL);

outcome api_ct_attach( ENTITY_LIST& body_list,
AcisOptions* ao = NULL);

outcome api_ct_attach_cells( LUMP* lump, AcisOptions* ao
= NULL);

outcome api_ct_cell_area( CELL* cell, double req_rel_accy,
double& area, double&est_rel_accy_achieved, AcisOptions* ao
= NULL);

outcome api_ct_cell_mass_pr( CELL3D* cell, SPAposition
    const&root_proj_pl, SPAunit_vector const&normal_proj_pl, int
    selector, double req_rel_accy, double& volume, SPAposition& cofg,
    tensor& inertia, double p_moments[], SPAunit_vector*
    p_axes[], double&est_rel_accy_achieved, AcisOptions* ao = NULL
    );

outcome api_ct_copy_cell( CELL* cell, BODY*& body,
AcisOptions* ao = NULL);

outcome api_ct_expand( ENTITY_LIST& body_list,
AcisOptions* ao = NULL);

outcome api_ct_expand_cells( LUMP* lump, AcisOptions* ao
= NULL);

outcome api_ct_flatten( ENTITY_LIST& body_list,
AcisOptions* ao = NULL);

outcome api_ct_flatten_cells( LUMP* lump, AcisOptions* ao
= NULL);

outcome api_ct_get_all_cells( ENTITY_LIST const& body_list,
ENTITY_LIST& cell_list, AcisOptions* ao = NULL);

outcome api_ct_lose_cells( LUMP* lump, AcisOptions* ao
= NULL);

outcome api_ct_lose_group( SPAGROUP* group, AcisOptions*
ao = NULL);

outcome api_ct_make_group( ENTITY_LIST& list,
SPAGROUP*& group, AcisOptions* ao = NULL);

outcome api_ct_point_in_cell( SPAposition const& test_point,
CELL3D* target_cell, point_containment& pc, AcisOptions* ao =
NULL);

outcome api_ct_propagate_cface_attribs( LUMP* lump,
AcisOptions* ao = NULL);

outcome api_ct_remove( ENTITY_LIST& body_list,
AcisOptions* ao = NULL);

outcome api_ct_remove_from_group( ENTITY* ent, SPAGROUP*
group, AcisOptions* ao = NULL);

outcome api_ct_return_ents( SPAGROUP* group,
ENTITY_LIST& list, AcisOptions* ao = NULL);

outcome api_ct_return_groups( ENTITY* ent, ENTITY_LIST&
list, AcisOptions* ao = NULL);

outcome api_ct_vacate_cell( CELL3D* cell, AcisOptions* ao
= NULL);

outcome api_curve_arc(const SPAposition& center, double
radius, double start_angle, double end_angle, EDGE*& arc,
AcisOptions* ao = NULL);

outcome api_curve_arc_3curve(const entity_with_ray& crv1,
const entity_with_ray& crv2, const entity_with_ray& crv3,
logical full, EDGE*& arc, AcisOptions* ao = NULL);

outcome api_curve_arc_3pt(const SPAposition& pt1, const
SPAposition& pt2, const SPAposition& pt3, logical full, EDGE*& arc,
AcisOptions* ao = NULL);

outcome api_curve_arc_center_edge(const SPAposition&
center, const SPAposition& pt1, const SPAposition& pt2, const
SPAunit_vector* norm, EDGE*& arc, AcisOptions* ao = NULL);

outcome api_curve_arc_diagonal(const SPAposition& pt1, const
SPAposition& pt2, logical full, EDGE*& arc, AcisOptions* ao =
NULL);

outcome api_curve_bezier(const SPAposition& pt1, const
SPAposition& pt2, const SPAposition& pt3, const SPAposition& pt4,
EDGE*& crv, AcisOptions* ao = NULL);

outcome api_curve_ellipse(const SPAposition& center, const
SPAposition& major, double ratio, double start_angle, double end_angle,
EDGE*& ell, AcisOptions* ao = NULL);

outcome api_curve_fillet(const entity_with_ray& crv1, const
entity_with_ray& crv2, double radius, logical trim1, logical trim2, EDGE*&
arc, AcisOptions* ao = NULL);

outcome api_curve_law( law* in_law, double start, double end,
curve*& new_curve, int law_number= 0, law** other_laws=
NULL, AcisOptions* ao = NULL);

outcome api_curve_line(const SPAposition& pt1, const
SPAposition& pt2, EDGE*& line, AcisOptions* ao = NULL);

outcome api_curve_line_tangent(const SPAposition* pt1, const
entity_with_ray* eray1, const SPAposition* pt2, const entity_with_ray*
eray2, EDGE*& line, AcisOptions* ao = NULL);

outcome api_curve_pattern( pattern*& pat, const
    curve& in_curve, const SPAinterval& param_range, int num_elements,
    const SPAposition& root, logical on_endpoints= FALSE, law*
    rail_law= NULL, const SPAvector& rail_dir
    =*(SPAvector*)NULL_REF, const SPAvector& tangent_dir
    =*(SPAvector*)NULL_REF, const SPAtransf& in_trans
    =*(SPAtransf*)NULL_REF, AcisOptions* ao = NULL);

outcome api_curve_spline(int numpts, const SPAposition* pts,
    const SPAunit_vector* start, const SPAunit_vector* end,
    EDGE*& crv, logical approx_ok = TRUE, logical periodic= FALSE,
    AcisOptions* ao = NULL);

outcome api_curve_spline2(int numpts, const SPAposition* pts,
const double* params, const SPAvector* start, const
SPAvector* end, EDGE*& crv, AcisOptions* ao= NULL);

outcome api_cylindrical_pattern( pattern*& pat, const
    FACE* in_face, int num_angular, int num_axial= 1, double ring_spacing
    = 0.0, logical alternating= FALSE, AcisOptions* ao = NULL
    );

outcome api_deep_copy_entity( ENTITY* entity,
ENTITY*& new_entity, logical dpcpy_skip= FALSE, AcisOptions* ao
= NULL);

outcome api_deep_copy_entity_list( ENTITY_LIST&
entity_list, ENTITY_LIST& new_entity_list, logical dpcpy_skip= FALSE,
AcisOptions* ao = NULL);

outcome api_delent( ENTITY* given_entity, AcisOptions* ao
= NULL);

outcome api_delete_blends( ENTITY_LIST const& ents_list,
AcisOptions* ao= NULL);

outcome api_delete_body_facets( BODY* body, AcisOptions*
ao = NULL);

outcome api_delete_ds( DELTA_STATE* ds);

outcome api_delete_entity_facets( ENTITY* entity,
AcisOptions* ao = NULL);

outcome api_delete_exp_blends( ENTITY_LIST const& ents_list,
AcisOptions* ao= NULL);

outcome api_delete_face_facets( FACE* face, AcisOptions*
ao = NULL);

outcome api_delete_history( HISTORY_STREAM* hs= NULL);

outcome api_delete_lump_facets( LUMP* lump, AcisOptions*
ao = NULL);

outcome api_delete_shell_facets( SHELL* shell,
AcisOptions* ao = NULL);

outcome api_delete_sli( AcisSLInterface* obj,
AcisOptions* opts = NULL);

outcome api_del_entity( ENTITY* given_entity,
AcisOptions* ao = NULL);

outcome api_del_entity_list( ENTITY_LIST& given_list,
AcisOptions* ao = NULL);

outcome api_detect_short_edges( ENTITY* entity,
ENTITY_LIST& returned_list, const double tolerance= SPAresfit, logical
replace= FALSE, AcisOptions* ao = NULL);

outcome api_detect_sliver_faces( ENTITY* entity,
ENTITY_LIST& returned_list, const double tolerance= -1, logical replace
= FALSE, AcisOptions* ao = NULL);

outcome api_distribute_state_to_streams( DELTA_STATE*
pState, StreamFinder* pStreamFinder, logical clearDelta, logical
hideStates);

outcome api_dm_add_multi_face( ATTRIB_DM2ACIS*
attrib_dm2acis, ENTITY* entity, int& entity_tag, int& tag_shift,
adm_options* adm_o= NULL, AcisOptions* acisO= NULL);

outcome api_dm_add_patch( ATTRIB_DM2ACIS*attrib_dm2acis,
    int shape_flag, SPApar_pos domain_pt1, SPApar_pos domain_pt2,
    SPApar_pos domain_pt3, int refinement, int tag_flag, int& patch_tag,
    adm_options* adm_o= NULL, AcisOptions* acisO= NULL);

outcome api_dm_auto_elevate(int y_n, adm_options* adm_o=
NULL, AcisOptions* acisO= NULL);

outcome api_dm_commit_attrib_dm2acis( ATTRIB_DM2ACIS*
attrib_dm2acis, adm_options* adm_o= NULL, AcisOptions* acisO=
NULL);

outcome api_dm_get_attrib_dm2acis( ENTITY* entity,
ATTRIB_DM2ACIS*&attrib_dm2acis, adm_options* adm_o= NULL,
AcisOptions* acisO= NULL);

outcome api_dm_get_hierarchy_entities( ATTRIB_DM2ACIS*
attrib_dm2acis, ENTITY_LIST& elist, adm_options* adm_o= NULL,
AcisOptions* acisO= NULL);

outcome api_dm_journal_off( adm_options* adm_o= NULL,
AcisOptions* acisO= NULL);

outcome api_dm_journal_on(char* filename, int cascade= 0,
adm_options* adm_o= NULL, AcisOptions* acisO= NULL);

outcome api_dm_query_attrib_dm2acis( DS_dmod* dmod,
ATTRIB_DM2ACIS*& dm2acis, adm_options* adm_o= NULL, AcisOptions* acisO
= NULL);

outcome api_dm_remove_attrib_dm2acis( ATTRIB_DM2ACIS*
attrib_dm2acis, adm_options* adm_o= NULL, AcisOptions* acisO=
NULL);

outcome api_dm_remove_dm_attributes( ENTITY* entity,
adm_options* adm_o= NULL, AcisOptions* acisO= NULL);

outcome api_dm_rm_multi_face( ATTRIB_DM2ACIS*
attrib_dm2acis, int tag, adm_options* adm_o= NULL, AcisOptions* acisO
= NULL);

outcome api_dm_rm_patch( ATTRIB_DM2ACIS* attrib_dm2acis, int
tag_flag, adm_options* adm_o= NULL, AcisOptions* acisO=
NULL);

outcome api_dm_set_array_size( DM_dbl_array& arr, int
new_size, double init_val= 0.0, adm_options* adm_o= NULL,
AcisOptions* acisO= NULL);

outcome api_dm_set_tolerance( adm_options* adm_o= NULL,
AcisOptions* acisO= NULL);

outcome api_dm_use_link_cstrns( adm_options* adm_o=
NULL, AcisOptions* acisO= NULL);

outcome api_do_one_blend_ss( blend1_data& bl1_data, int
index, BODY* sheet_body, AcisOptions* ao= NULL);

outcome api_edent_rel( EDGE* edge, ENTITY* entity,
edge_entity_rel*& rel, AcisOptions* ao = NULL);

outcome api_edfa_int( EDGE* edge, FACE* face,
ENTITY_LIST*& inter, AcisOptions* ao = NULL);

outcome api_edge( EDGE* edgeIn, EDGE*& edgeOut,
AcisOptions* ao = NULL);

outcome api_edge_arclength_metric( EDGE* edgeIn, double&
metric, AcisOptions* ao = NULL);

outcome api_edge_arclength_param( EDGE* edgeIn, logical
approx_ok, double tol, EDGE*& edgeOut, AcisOptions* ao = NULL
);

outcome api_edge_convexity_param( EDGE* edge, double p,
bl_ed_convexity& cxty, AcisOptions* ao = NULL);

outcome api_edge_helix( SPAposition axis_start, SPAposition
    axis_end, SPAvector start_dir, double radius, double thread_distance,
    logical handiness, EDGE*& new_edge, AcisOptions* ao = NULL
    );

outcome api_edge_law( law* inlaw, double start, double end,
EDGE*& new_edge, int law_number= 0, law** other_laws=
NULL, AcisOptions* ao = NULL);

outcome api_edge_pattern( pattern*& pat, COEDGE*
    in_coedge, int number, const SPAposition& root, logical on_endpoints=
    FALSE, const SPAvector& normal_dir
    =*(SPAvector*)NULL_REF, const SPAvector& tangent_dir law
    =*(SPAvector*)NULL_REF, AcisOptions* ao = NULL);

outcome api_edge_plaw( FACE* in_face, law* inlaw, double
start, double end, EDGE*& new_edge, int law_number= 0,
law** other_laws= NULL, AcisOptions* ao = NULL);

outcome api_edge_spiral( SPAposition& center, SPAvector&
    normal, SPAposition&start_position, double width, double angle,
    EDGE*& spiral, logical handedness= TRUE, AcisOptions* ao =
    NULL);

outcome api_edge_spring( SPAposition& axis_point,
    SPAvector& axis_vector, SPAposition& start_position, logical
    handedness, int helix_count, double*thread_distance_array, double*
    rotation_angle_array, double*transition_height_array, double*
    transition_angle_array, EDGE*& crv, AcisOptions* ao = NULL);

outcome api_edge_spring_law( SPAposition& axis_point,
    SPAvector& axis_vector, SPAposition& start_position, law*
    variable_radius_law, logical handedness, int helix_count, double*
    thread_distance_array, double*rotation_angle_array, double*
    transition_height_array, double*transition_angle_array, EDGE*& crv,
    AcisOptions* ao = NULL);

outcome api_edge_spring_taper( SPAposition& axis_point,
    SPAvector& axis_vector, SPAposition& start_position, double
    taper_angle, logical handedness, int helix_count, double*
    thread_distance_array, double*rotation_angle_array, double*
    transition_height_array, double*transition_angle_array, EDGE*& crv,
    AcisOptions* ao = NULL);

outcome api_edge_taper_faces(int const nface, FACE*
    face[], EDGE* edge[], SPAunit_vector const& draft_dir,
    double const& draft_angle, SPAposition box_low, SPAposition
    box_high, AcisOptions* ao = NULL);

outcome api_edge_to_spline( EDGE* e1, EDGE*& e2,
AcisOptions* ao = NULL);

outcome api_ed_inters_to_ents( EDGE* e1,
curve_curve_int* inters, ENTITY_LIST& ents, AcisOptions* ao = NULL);

outcome api_ed_self_inters( EDGE* edge,
curve_curve_int*&self_intersection, AcisOptions* ao = NULL);

outcome api_elliptical_pattern( pattern*& pat, const
    SPAposition& center, const SPAvector& normal, int num_elements, logical
    not_rotate= FALSE, const SPAposition& root
    =*(SPAposition*)NULL_REF, double angle= 2.0* 3.14159265358979323846, double ratio
    = 1.0, const SPAvector& major_axis
    =*(SPAvector*)NULL_REF, AcisOptions* ao = NULL);

outcome api_enclose_void( FACE* face, REVBIT sense, logical
lumps, AcisOptions* ao = NULL);

outcome api_end_journal( AcisOptions* ao);

outcome api_ensure_empty_root_state( HISTORY_STREAM*
history, DELTA_STATE*& root_state);

outcome api_entity_entity_distance( ENTITY* ent1,
    ENTITY* ent2, SPAposition& pos1, SPAposition& pos2, double&
    distance, param_info& ent1_info=*(param_info*)NULL_REF,
    param_info& ent2_info=*(param_info*)NULL_REF,
    AcisOptions* ao = NULL);

outcome api_entity_entity_touch( ENTITY* ent1, ENTITY*
ent2, logical& touch, AcisOptions* ao = NULL);

outcome api_entity_extrema( ENTITY_LIST& ents, int nvec,
SPAvector* in_vec, SPAposition& max_pos, param_info& out_info
=*(param_info*)NULL_REF, AcisOptions* ao = NULL);

outcome api_entity_point_distance( ENTITY* ent,
    SPAposition& in_point, SPAposition& closest_pos, double& distance,
    param_info& ent_info=*(param_info*)NULL_REF, AcisOptions*
    ao = NULL);

outcome api_ent_area( ENTITY* ent, double req_rel_accy,
double& area, double& est_rel_accy_achieved, AcisOptions* ao
= NULL);

outcome api_estimate_min_rad_curvature_skin(
AcisSLInterface* obj, double& min_rad, AcisOptions* opts = NULL);

outcome api_estimate_tangent_factor_scale_li(
    AcisLoftingInterface* obj, SPAinterval& range, double& optimum
    =*(double*)NULL_REF, double& min_radius=*(double*)NULL_REF,
    AcisOptions* opts = NULL);

outcome api_expand_body( BODY* body, AcisOptions* ao =
NULL);

outcome api_extract_coed_info( COEDGE* coedge, logical
forward, logical outward, int num_pts, SPAposition* pts,
SPAunit_vector* tans);

outcome api_faceted_face( FACE* face, logical& faceted,
AcisOptions* ao = NULL);

outcome api_facet_area( ENTITY* entity, double& area,
AcisOptions* ao= NULL);

outcome api_facet_body( BODY* body, AcisOptions* ao =
NULL);

outcome api_facet_curve(const curve& crv, double a, double b,
double tol, int nmax, int& npts, nmax if nmax exceeded) SPAposition
pts[], double t[], AcisOptions* ao = NULL);

outcome api_facet_entities( ENTITY* owner, ENTITY_LIST*
entity_list, AcisOptions* ao = NULL);

outcome api_facet_entity( ENTITY* entity, AcisOptions* ao
= NULL);

outcome api_facet_face( FACE* face, AcisOptions* ao =
NULL);

outcome api_facet_lump( LUMP* lump, AcisOptions* ao =
NULL);

outcome api_facet_shell( SHELL* shell, AcisOptions* ao
= NULL);

outcome api_facet_unfaceted_entities( ENTITY* owner,
ENTITY_LIST* entity_list, AcisOptions* ao = NULL);

outcome api_facet_unfaceted_entity( ENTITY* entity,
AcisOptions* ao = NULL);

outcome api_face_conic(double radius, double conic_const, double
extent, double length, FACE*& face, AcisOptions* ao = NULL
);

outcome api_face_cylinder_cone(const SPAposition& center,
    const SPAvector& normal, double bottom, double top, double start,
    double end, double ratio, const SPAposition* pt, FACE*& face,
    AcisOptions* ao = NULL);

outcome api_face_law( law* in_law, double minu, double maxu,
double minv, double maxv, FACE*& face, int in_law_number= 0,
law** in_other_laws= NULL, AcisOptions* ao = NULL);

outcome api_face_nu_nv_isolines(int nu, int nv, FACE* face,
const SPAtransf& ftrans, ENTITY_LIST* edge_list,
AcisOptions* ao = NULL);

outcome api_face_plane(const SPAposition& p, double width,
double height, const SPAvector* normal, FACE*& face,
AcisOptions* ao = NULL);

outcome api_face_sphere(const SPAposition& center, double
    radius, double lo_start, double lo_end, double la_start, double la_end,
    const SPAvector* normal, FACE*& face, AcisOptions* ao
    = NULL);

outcome api_face_spl_apprx(const splgrid* grid,
FACE*& face, AcisOptions* ao = NULL);

outcome api_face_spl_ctrlpts(const splsurf* surf,
FACE*& face, AcisOptions* ao = NULL);

outcome api_face_spl_intrp(const splgrid* grid,
FACE*& face, AcisOptions* ao = NULL);

outcome api_face_torus(const SPAposition& center, double
    major, double minor, double tu_start, double tu_end, double sv_start,
    double sv_end, const SPAvector* normal, FACE*& face,
    AcisOptions* ao = NULL);

outcome api_face_u_iso(double v, FACE* face, const
SPAtransf& ftrans, ENTITY_LIST* edge_list, AcisOptions* ao = NULL
);

outcome api_face_v_iso(double u, u parameter FACE* face, const
SPAtransf& ftrans, ENTITY_LIST* edge_list, AcisOptions* ao = NULL
);

outcome api_fafa_int( FACE* tool, FACE* blank,
BODY*& graph, AcisOptions* ao = NULL);

outcome api_fast_find_face( SPAposition const& ray_pos,
    SPAunit_vector const& ray_dir, BODY* in_body, int& in_count,
    ENTITY**& in_faces=*(ENTITY***)NULL_REF,
    SPAposition*& in_hits=*(SPAposition**)NULL_REF,
    double*& in_params=*(double**)NULL_REF,
    AcisOptions* ao = NULL);

outcome api_fillet_vertex( VERTEX* vert, double radius,
EDGE* edge1= NULL, EDGE* edge2= NULL, AcisOptions* ao
= NULL);

outcome api_find_annotations( ENTITY_LIST&, is_fun=
is_ANNOTATION, BULLETIN_BOARD* bb= NULL, AcisOptions* = NULL);

outcome api_find_cls_ptto_face(const SPAposition&
from_point, FACE* face, SPAposition& to_point, AcisOptions* ao
= NULL);

outcome api_find_face( BODY* body, SPAunit_vector const&
direction, FACE*& face, AcisOptions* ao = NULL);

outcome api_find_named_attribute( ENTITY* ent, const
char* name, ATTRIB_GEN_NAME*& ret_att, AcisOptions* ao
= NULL);

outcome api_find_named_state(const char* name,
HISTORY_STREAM* hs, DELTA_STATE_LIST& dslist);

outcome api_find_vertex( BODY* body, SPAposition const&
pos, VERTEX*& vertex, AcisOptions* ao = NULL);

outcome api_fixup_intersection(int edge_knt, EDGE**
edge_array, FACE** tfaces, AcisOptions* ao= NULL);

outcome api_fix_blends( ENTITY_LIST const& ents,
AcisOptions* ao= NULL);

outcome api_flatten_body( BODY* body, AcisOptions* ao
= NULL);

outcome api_get_active_entities( HISTORY_STREAM const* hs,
ENTITY_LIST& ents, logical unowned_only= FALSE, AcisOptions* ao =
NULL);

PART* api_get_active_part();

outcome api_get_active_state( DELTA_STATE*& active_ds,
HISTORY_STREAM* hs= NULL);

outcome api_get_all_user_attributes( HISTORY_STREAM const*
hs, int derivation_level, int attrib_type_code, ENTITY_LIST&
attribs, logical active_only= TRUE, AcisOptions* ao = NULL);

outcome api_get_annotation_ctx( annotation_ctx*& list,
AcisOptions* = NULL);

outcome api_get_body_facets( BODY* body,
POLYGON_POINT_MESH*& pmesh, logical share_edge_vertices= TRUE, AcisOptions* ao
= NULL);

outcome api_get_body_refinement( BODY* body,
REFINEMENT*& ref, AcisOptions* ao = NULL);

outcome api_get_body_vertex_template( BODY* body,
VERTEX_TEMPLATE*& tplate, AcisOptions* ao = NULL);

outcome api_get_coedges( ENTITY* ent, ENTITY_LIST&
coedge_list, PAT_NEXT_TYPE include_pat= PAT_CAN_CREATE, AcisOptions*
ao = NULL);

outcome api_get_curve_ends( EDGE* crv, SPAposition& pt1,
SPAposition& pt2, AcisOptions* ao = NULL);

outcome api_get_default_history( HISTORY_STREAM*&
default_hs);

outcome api_get_default_refinement( REFINEMENT*& ref,
AF_SURF_MODE surftype= AF_SURF_ALL, AcisOptions* ao = NULL);

outcome api_get_default_vertex_template(
VERTEX_TEMPLATE*& tplate, AcisOptions* ao = NULL);

outcome api_get_edges( ENTITY* ent, ENTITY_LIST&
edge_list, PAT_NEXT_TYPE include_pat= PAT_CAN_CREATE, AcisOptions*
ao = NULL);

outcome api_get_edges_from_all_entities( ENTITY* ent,
ENTITY_LIST& edge_list, PAT_NEXT_TYPE include_pat= PAT_CAN_CREATE,
AcisOptions* ao = NULL);

outcome api_get_ellipse_parameters( EDGE* ell,
    SPAposition& center, SPAunit_vector& normal, SPAvector& major_axis,
    double& radius_ratio, double& start_angle, double& end_angle,
    AcisOptions* ao = NULL);

outcome api_get_entities( ENTITY* ent, ENTITY_LIST&
ent_list, ENTITY_ID topology_ids, ENTITY_ID geometry_ids, PAT_NEXT_TYPE
include_pat= PAT_CAN_CREATE, AcisOptions* ao = NULL);

outcome api_get_entity_box(const ENTITY_LIST& ent_list,
WCS* wcs, SPAposition& min_pt, SPAposition& max_pt,
AcisOptions* ao = NULL);

outcome api_get_entity_from_id( tag_id_type id, ENTITY*&
returned_ent, HISTORY_STREAM* hs= NULL);

outcome api_get_entity_id( ENTITY* ent, tag_id_type& id);

outcome api_get_entity_refinement( ENTITY* entity,
REFINEMENT*& ref, AF_SURF_MODE surftype= AF_SURF_ALL, AcisOptions* ao
= NULL);

outcome api_get_ents( SPAposition const& ray_point,
    SPAunit_vector const&ray_direction, double ray_radius, int type_wanted,
    BODY* target_body, ENTITY_LIST& entities_hit, double*&
    ray_parameters, AcisOptions* ao = NULL);

outcome api_get_faces( ENTITY* ent, ENTITY_LIST&
face_list, PAT_NEXT_TYPE include_pat= PAT_CAN_CREATE, AcisOptions*
ao = NULL);

outcome api_get_faces_from_all_entities( ENTITY* ent,
ENTITY_LIST& face_list, PAT_NEXT_TYPE include_pat= PAT_CAN_CREATE,
AcisOptions* ao = NULL);

outcome api_get_facet_edge_points( EDGE* edge,
SPAposition*& polyline, int& num_pts, AcisOptions* ao = NULL);

outcome api_get_face_facets( FACE* face,
POLYGON_POINT_MESH*& pmesh, logical share_edge_vertices= TRUE, AcisOptions* ao
= NULL);

outcome api_get_face_refinement( FACE* face,
REFINEMENT*& ref, AcisOptions* ao = NULL);

outcome api_get_face_vertex_template( FACE* face,
VERTEX_TEMPLATE*& tplate, AcisOptions* ao = NULL);

outcome api_get_file_info( FileInfo& info);

outcome api_get_history_from_entity( ENTITY* ent,
HISTORY_STREAM*& hs);

outcome api_get_history_size( HISTORY_STREAM* hs, int&
size, DELTA_STATE* start_ds= NULL);

outcome api_get_indexed_mesh( ENTITY* entity,
INDEXED_MESH*& mesh, AcisOptions* ao = NULL);

outcome api_get_journal( AcisOptions* ao,
AcisJournal*& aj);

outcome api_get_loops( ENTITY* ent, ENTITY_LIST&
loop_list, PAT_NEXT_TYPE include_pat= PAT_CAN_CREATE, AcisOptions*
ao = NULL);

outcome api_get_lumps( ENTITY* ent, ENTITY_LIST&
lump_list, PAT_NEXT_TYPE include_pat= PAT_CAN_CREATE, AcisOptions*
ao = NULL);

outcome api_get_lump_facets( LUMP* lump,
POLYGON_POINT_MESH*& pmesh, logical share_edge_vertices= TRUE, AcisOptions* ao
= NULL);

outcome api_get_lump_refinement( LUMP* lump,
REFINEMENT*& ref, AcisOptions* ao = NULL);

outcome api_get_lump_vertex_template( LUMP* lump,
VERTEX_TEMPLATE*& tplate, AcisOptions* ao = NULL);

outcome api_get_mesh_manager( MESH_MANAGER*&
mesh_manager, AcisOptions* ao = NULL);

outcome api_get_modified_faces( DELTA_STATE* ds,
ENTITY_LIST& deleted_faces, ENTITY_LIST& created_faces, ENTITY_LIST&
modified_faces, AcisOptions* ao = NULL);

outcome api_get_owner( ENTITY* ent, ENTITY*& owner,
AcisOptions* ao = NULL);

outcome api_get_save_version(int& major_version, int&
minor_version);

outcome api_get_shells( ENTITY* ent, ENTITY_LIST&
shell_list, PAT_NEXT_TYPE include_pat= PAT_CAN_CREATE, AcisOptions*
ao = NULL);

outcome api_get_shell_facets( SHELL* shell,
POLYGON_POINT_MESH*& pmesh, logical share_edge_vertices= TRUE, AcisOptions* ao
= NULL);

outcome api_get_shell_refinement( SHELL* shell,
REFINEMENT*& ref, AcisOptions* ao = NULL);

outcome api_get_shell_vertex_template( SHELL* shell,
VERTEX_TEMPLATE*& tplate, AcisOptions* ao = NULL);

outcome api_get_state_from_id( STATE_ID id,
DELTA_STATE*& returned_ds, HISTORY_STREAM* hs= NULL);

outcome api_get_state_id( DELTA_STATE* ds, STATE_ID& id);

outcome api_get_tangent_factors_li( AcisLoftingInterface*
obj, double*& tan_factors, AcisOptions* opts = NULL);

outcome api_get_tcoedges( ENTITY* ent, ENTITY_LIST&
tcoedge_list PAT_NEXT_TYPE include_pat= PAT_CAN_CREATE, AcisOptions*
ao = NULL);

outcome api_get_tedges( ENTITY* ent, ENTITY_LIST&
tedge_list, PAT_NEXT_TYPE include_pat= PAT_CAN_CREATE, AcisOptions*
ao = NULL);

outcome api_get_tvertices( ENTITY* ent, ENTITY_LIST&
tvertex_list, PAT_NEXT_TYPE include_pat= PAT_CAN_CREATE, AcisOptions*
ao = NULL);

outcome api_get_version_tag( AcisVersion* av, int& tag);

outcome api_get_vertices( ENTITY* ent, ENTITY_LIST&
vertex_list, PAT_NEXT_TYPE include_pat= PAT_CAN_CREATE, AcisOptions*
ao = NULL);

outcome api_get_vertices_from_all_entities( ENTITY* ent,
ENTITY_LIST& vertex_list, PAT_NEXT_TYPE include_pat= PAT_CAN_CREATE,
AcisOptions* ao = NULL);

outcome api_get_wires( ENTITY* ent, ENTITY_LIST&
out_list, PAT_NEXT_TYPE include_pat= PAT_CAN_CREATE, AcisOptions*
ao = NULL);

outcome api_heal_edges_to_regions( ENTITY_LIST& eds, double
coincident_tol, double length_limit, BODY*& outbdy, int wire_only=
FALSE, FILE* fptr= NULL, AcisOptions* ao = NULL);

outcome api_hedgehog( law* field, law* base, double*
starts, double* ends, int dim, int* hairs, ENTITY_LIST&
return_item, AcisOptions* ao = NULL);

outcome api_hex_cylindrical_pattern( pattern*& pat,
const FACE* in_face, int num_angular, int num_axial= 1, double
spacing= 0.0, AcisOptions* ao = NULL);

outcome api_hex_pattern( pattern*& pat, const
SPAvector& normal, const SPAvector& x_vec, int num_x, int num_y, int num_z
= 1, AcisOptions* ao = NULL);

outcome api_hh_analytic_analyze( BODY*, AcisOptions* ao
= NULL);

outcome api_hh_analytic_auto( BODY*, AcisOptions* ao
= NULL);

outcome api_hh_analytic_calc_fix( BODY*, AcisOptions* ao
= NULL);

outcome api_hh_analyze_body( BODY* body, AcisOptions* ao
= NULL);

outcome api_hh_analyze_coedges( BODY* body, AcisOptions*
ao = NULL);

outcome api_hh_analyze_edges( BODY* body, AcisOptions* ao
= NULL);

outcome api_hh_analyze_faces( BODY* body, AcisOptions* ao
= NULL);

outcome api_hh_analyze_loops( BODY* body, AcisOptions* ao
= NULL);

outcome api_hh_analyze_lumps( BODY* body, AcisOptions* ao
= NULL);

outcome api_hh_analyze_shells( BODY* body, AcisOptions*
ao = NULL);

outcome api_hh_analyze_vertices( BODY* body,
AcisOptions* ao = NULL);

outcome api_hh_auto_heal( BODY* body, AcisOptions* ao
= NULL);

outcome api_hh_end_body_for_healing( BODY* body,
AcisOptions* ao = NULL);

outcome api_hh_force_simplify_to_cone( FACE* inp_face,
AcisOptions* ao = NULL);

outcome api_hh_force_simplify_to_cylinder( FACE* inp_face,
AcisOptions* ao = NULL);

outcome api_hh_force_simplify_to_plane( FACE* inp_face,
AcisOptions* ao = NULL);

outcome api_hh_force_simplify_to_sphere( FACE* inp_face,
AcisOptions* ao = NULL);

outcome api_hh_force_simplify_to_torus( FACE* inp_face,
AcisOptions* ao = NULL);

outcome api_hh_gen_spline_analyze( BODY*, AcisOptions*
ao = NULL);

outcome api_hh_gen_spline_auto( BODY*, AcisOptions* ao
= NULL);

outcome api_hh_gen_spline_calc_fix( BODY*, AcisOptions*
ao = NULL);

outcome api_hh_geombuild_analyze( BODY*, AcisOptions* ao
= NULL);

outcome api_hh_geombuild_auto( BODY*, AcisOptions* ao
= NULL);

outcome api_hh_geombuild_calc_fix( BODY*, AcisOptions*
ao = NULL);

outcome api_hh_geombuild_check( BODY*, AcisOptions* ao
= NULL);

outcome api_hh_geombuild_cleanup( BODY*, AcisOptions* ao
= NULL);

outcome api_hh_get_bad_coedges( BODY* body, ENTITY_LIST&
list, AcisOptions* ao = NULL);

outcome api_hh_get_bad_edges( BODY* body, ENTITY_LIST&
list, AcisOptions* ao = NULL);

outcome api_hh_get_bad_faces( BODY* body, ENTITY_LIST&
list, AcisOptions* ao = NULL);

outcome api_hh_get_bad_loops( BODY* body, ENTITY_LIST&
list, AcisOptions* ao = NULL);

outcome api_hh_get_bad_lumps( BODY* body, ENTITY_LIST&
list, AcisOptions* ao = NULL);

outcome api_hh_get_bad_shells( BODY* body, ENTITY_LIST&
list, AcisOptions* ao = NULL);

outcome api_hh_get_bad_vertices( BODY* body,
ENTITY_LIST& list, AcisOptions* ao = NULL);

outcome api_hh_get_entity_details( ENTITY* entity,
char*& history, AcisOptions* ao = NULL);

outcome api_hh_init_body_for_healing( BODY* body,
AcisOptions* ao = NULL);

outcome api_hh_isospline_analyze( BODY*, AcisOptions* ao
= NULL);

outcome api_hh_isospline_auto( BODY*, AcisOptions* ao
= NULL);

outcome api_hh_isospline_calc_fix( BODY*, AcisOptions*
ao = NULL);

outcome api_hh_make_tolerant( BODY* body, AcisOptions* ao
= NULL);

outcome api_hh_postprocess( BODY* body, AcisOptions* ao
= NULL);

outcome api_hh_preprocess( BODY* body, AcisOptions* ao
= NULL);

outcome api_hh_sharp_edge_analyze( BODY*, AcisOptions*
ao = NULL);

outcome api_hh_sharp_edge_auto( BODY*, AcisOptions* ao
= NULL);

outcome api_hh_sharp_edge_calc_fix( BODY*, AcisOptions*
ao = NULL);

outcome api_hh_simplify_analyze( BODY* inp_body,
AcisOptions* ao = NULL);

outcome api_hh_simplify_auto( BODY* inp_body,
AcisOptions* ao = NULL);

outcome api_hh_simplify_calculate( BODY* inp_body,
AcisOptions* ao = NULL);

outcome api_hh_simplify_cleanup( BODY* inp_body,
AcisOptions* ao = NULL);

outcome api_hh_simplify_fix( BODY* inp_body,
AcisOptions* ao = NULL);

outcome api_hh_stitch_analyze( BODY* inp_body,
AcisOptions* ao = NULL);

outcome api_hh_stitch_auto( BODY* inp_body, AcisOptions*
ao = NULL);

outcome api_hh_stitch_calculate( BODY* inp_body,
AcisOptions* ao = NULL);

outcome api_hh_stitch_cleanup( BODY* inp_body,
AcisOptions* ao = NULL);

outcome api_hh_stitch_fix( BODY* inp_body, AcisOptions*
ao = NULL);

outcome api_hh_store_entity_details( BODY* body, logical
option_value, AcisOptions* ao = NULL);

outcome api_hh_wrapup_analyze( BODY*, AcisOptions* ao
= NULL);

outcome api_hh_wrapup_auto( BODY*, AcisOptions* ao =
NULL);

outcome api_hh_wrapup_calc_fix( BODY*, AcisOptions* ao
= NULL);

outcome api_hollow_body( BODY* body, int const nopenface,
FACE* openface[], double thickness, SPAposition box_low,
SPAposition box_high, AcisOptions* ao= NULL);

outcome api_hollow_body_specific( BODY* body, int const
    nopenface, FACE* openface[], double inner_default_offset,
    double outer_default_offset, int const n_spec_inner, FACE*
    spec_inner_face[], double spec_inner_off[], int const n_spec_outer,
    FACE* spec_outer_face[], double spec_outer_off[],
    SPAposition box_low, SPAposition box_high, AcisOptions* ao = NULL);

outcome api_hook_annotations( is_fun is_function=
is_ANNOTATION, BULLETIN_BOARD* bb= NULL, AcisOptions* ao = NULL);

outcome api_ihl_clean(const ENTITY_LIST& entities, int token
);

outcome api_ihl_compute(const ENTITY_LIST& entities, int
    token, const SPAposition& eyepos, const SPAposition& target,
    logical fPersp, logical fIntrSeg, logical fHidSeg, logical unfacetted,
    logical fNoHidCalc, ENTITY_LIST& segments);

outcome api_ihl_compute_entity_silhouette(const
    ENTITY_LIST&entities, const SPAposition& eyepos, const SPAposition&
    target, logical fPersp, logical fHidSeg, logical unfacetted, logical
    fNoHidCalc, ENTITY_LIST& segments);

outcome api_ihl_compute_from_meshes(POLYEDGE_MESH*
meshs[], TRANSFORM* transfs[], int num_meshs, const
SPAposition& eyepos, const SPAposition& target, logical fPersp);

outcome api_ihl_facet(const ENTITY_LIST& entities, logical
unfacetted);

outcome api_ihl_get_mesh( ENTITY* entity,
POLYEDGE_MESH*& mesh);

outcome api_ihl_get_output_manager(
IHL_OUTPUT_MANAGER*& ihlOM);

outcome api_ihl_occlusion( ENTITY_LIST& ihl_segs, double tol
= SPAresfit);

outcome api_ihl_retrieve(const ENTITY_LIST& entities, int
token, ENTITY_LIST& segments, IHL_CAMERA*& camera);

outcome api_ihl_set_output_manager( IHL_OUTPUT_MANAGER*
ihlOM);

outcome api_imprint( BODY* tool, BODY* blank,
AcisOptions* ao = NULL);

outcome api_imprint_complete( BODY* tool, BODY* blank,
AcisOptions* ao = NULL);

outcome api_imprint_stitch( BODY* b1, BODY* b2,
AcisOptions* ao = NULL);

outcome api_imprint_stitch_complete( BODY* b1, BODY* b2,
AcisOptions* ao = NULL);

outcome api_initialise_faceter( MESH_MANAGER* mesh_manager
=(MESH_MANAGER*)-1);

outcome api_initialize_admhoops();

outcome api_initialize_admicon( adm_options* adm_o=
NULL, AcisOptions* acisO= NULL);

outcome api_initialize_advanced_blending();

outcome api_initialize_blending();

outcome api_initialize_booleans();

outcome api_initialize_cellular_topology();

outcome api_initialize_clearance();

outcome api_initialize_constructors();

outcome api_initialize_covering();

outcome api_initialize_deformable_modeling( adm_options*
adm_o= NULL, AcisOptions* acisO= NULL);

outcome api_initialize_euler_ops();

outcome api_initialize_faceter();

outcome api_initialize_face_removal();

outcome api_initialize_generic_attributes();

outcome api_initialize_healing();

outcome api_initialize_hidden_line_removal();

outcome api_initialize_interactive_hidden_line();

outcome api_initialize_intersectors();

outcome api_initialize_kernel();

outcome api_initialize_local_ops();

outcome api_initialize_lopt_ops();

outcome api_initialize_offsetting();

outcome api_initialize_operators();

outcome api_initialize_part_manager();

outcome api_initialize_persistent_id();

outcome api_initialize_precise_hidden_line();

outcome api_initialize_rbi();

outcome api_initialize_rendering();

outcome api_initialize_sbooleans();

outcome api_initialize_shelling();

outcome api_initialize_skinning();

outcome api_initialize_spline();

outcome api_initialize_stitching();

outcome api_initialize_sweeping();

outcome api_initialize_warp();

outcome api_init_blend_ss( blend1_data& bl1_data,
BODY*& sheet_body, AcisOptions* ao= NULL);

outcome api_integrate_law( law* input_law, double start,
double end, double& answer, double tolerance= 1E-12, int min_level
= 2, int* used_level= NULL);

outcome api_integrate_law_wrt( law* input_law, double start,
double end, int wrt, double* along, double& answer, double
tolerance= 1E-12, int min_level= 2, int* used_level= NULL);

outcome api_integrate_law_wrt_and_splits( law* input_law,
    double start, double end, int wrt, double* along, double& answer,
    int number_of_splits= 0, double* splits= NULL, double
    tolerance= 1E-12, int min_level= 2, int* used_level= NULL);

outcome api_intersect( BODY* tool, BODY* blank,
AcisOptions* ao = NULL);

outcome api_intersect_curves( EDGE* crv1, EDGE* crv2,
logical bounded, curve_curve_int*& inters, AcisOptions* ao
= NULL);

outcome api_inter_ed_ed( EDGE* e1, EDGE* e2,
curve_curve_int*& inters, AcisOptions* ao = NULL);

outcome api_join_edges( ENTITY_LIST& edge_list,
EDGE*& resulting_edge, logical join_c1= TRUE, AcisOptions* ao
= NULL);

outcome api_law_to_entity( law* input_law, ENTITY*&
out_ent, AcisOptions* ao = NULL);

outcome api_linear_pattern( pattern*& pat, const
    SPAvector& x_vec, int num_x, const SPAvector& y_vec
    =*(SPAvector*)NULL_REF, int num_y= 1, const SPAvector& z_vec
    =*(SPAvector*)NULL_REF, int num_z= 1, logical y_staggered= FALSE, logical
    z_staggered= FALSE, logical fit_distance= FALSE, AcisOptions* ao
    = NULL);

outcome api_linear_scale_pattern( pattern*& pat, const
    pattern& in_pattern, double first_scale, double last_scale, int which_dim,
    const SPAposition& root, logical merge= TRUE, AcisOptions*
    ao = NULL);

outcome api_load_state(FILE* file_ptr, AcisOptions* ao
= NULL);

outcome api_loft_coedges(int n_set,
Loft_Connected_Coedge_List*set_ce_list, BODY*& sheet_body, skin_options* opts,
AcisOptions* ao = NULL);

outcome api_loft_faces( FACE* face1, double fact1, FACE*
face2, double fact2, BODY*& body, skin_options* opts,
AcisOptions* ao = NULL);

outcome api_logging(logical on_off);

outcome api_loop_external( LOOP* given_loop, logical*
if_external, AcisOptions* ao = NULL);

outcome api_loop_type( LOOP* in_loop, loop_type& type, int
info[]= NULL);

outcome api_lose_surface_conditions_li(
AcisLoftingInterface* obj, AcisOptions* opts = NULL);

outcome api_make_approx_curve( curve const* input_curve,
double const tol, SPAinterval range, curve*& output_curve,
AcisOptions* ao = NULL);

outcome api_make_approx_surface( surface const*
    input_surface, double const tol, SPAinterval const& u_range, SPAinterval
    const& v_range, surface*& output_surface, AcisOptions* ao
    = NULL);

outcome api_make_blend_cross_curve(const ATTRIB_BLEND* att,
double v_param, curve*& ccrv, AcisOptions* ao= NULL);

outcome api_make_blend_sheet( ENTITY_LIST const& ent_list,
BODY*& sheet_body, AcisOptions* ao= NULL);

outcome api_make_blend_wire( BODY* sheet_body, BODY*
blank_body, BODY*& wire_body, AcisOptions* ao= NULL);

outcome api_make_cnface(const SPAposition& center, const
    SPAunit_vector& normal_axis, const SPAvector& major_axis, double
    radius_ratio, double sint, double cost, double st_ang, double end_ang, double
    height, FACE*& face, AcisOptions* ao = NULL);

outcome api_make_cubic(double aval, double bval, double faval,
double fbval, double ffaval, double ffbval, law*& answer);

outcome api_make_cuboid(double width, xdouble depth, ydouble
height, z BODY*& body, AcisOptions* ao = NULL);

outcome api_make_edge_from_curve( curve const* cur,
EDGE*& edge, AcisOptions* ao = NULL);

outcome api_make_ewire(int num_edges, EDGE* edges[],
BODY*& body, AcisOptions* ao = NULL);

outcome api_make_ewires(int num_edges, EDGE*
edges[], int& n_bodies, BODY**& bodies, AcisOptions*
ao = NULL);

outcome api_make_flat_on_faces( SPAposition ptPosition, double
    offset, SPAunit_vector* normal= NULL, FACE** faces=
    NULL, int n_faces= 1, BODY* owner= NULL, AcisOptions* ao
    = NULL);

outcome api_make_frustum(double height, double rad1, double rad2,
double top, BODY*& body, AcisOptions* ao = NULL);

outcome api_make_kwire( BODY* given_body, SPAunit_vector
const& normal, int length_pts, SPAposition array_pts[], double
array_bulges[], BODY*& body, AcisOptions* ao = NULL);

outcome api_make_linear(double aval, double bval, double faval,
double fbval, law*& answer);

outcome api_make_mapping_curves_sli( AcisSLInterface* obj,
ENTITY_LIST& edgeList, AcisOptions* opts = NULL);

outcome api_make_planar_disk(const SPAposition& origin,
const SPAunit_vector& normal, double radius, FACE*& face,
logical half_space= FALSE, AcisOptions* ao = NULL);

outcome api_make_plface(const SPAposition& origin, const
SPAposition& left, const SPAposition& right, FACE*& face,
AcisOptions* ao = NULL);

outcome api_make_polygon( BODY*& polygon, SPAposition
    centre, SPAvector start, SPAvector& normal, double& side_length,
    int number_of_sides= 6, logical oncenter= FALSE,
    AcisOptions* ao = NULL);

outcome api_make_polynomial_law(double* coeff, int degree,
law*& answer);

outcome api_make_prism(double height, double rad1, double rad2, int
nsides, BODY*& body, AcisOptions* ao = NULL);

outcome api_make_pyramid(double height, double rad1, double rad2,
double top, int nsides, BODY*& body, AcisOptions* ao = NULL
);

outcome api_make_quintic(double aval, double bval, double faval,
double fbval, double ffaval, double ffbval, double fffaval, double fffbval,
law*& answer);

outcome api_make_radius_constant(double rad,
var_radius*& rad_obj, AcisOptions* ao = NULL);

outcome api_make_radius_fixed_width(double width,
var_radius*& rad_obj, AcisOptions* ao = NULL);

outcome api_make_radius_param_rads(int num_fixes, double*
fix_params, double* fix_radii, var_radius*& rad_obj,
AcisOptions* ao = NULL);

outcome api_make_radius_param_rads_tan(int num_fixes,
    double* fix_params, double* fix_radii, double* start_slope,
    double* end_slope, var_radius*& rad_obj, AcisOptions* ao
    = NULL);

outcome api_make_radius_pos_rads( CURVE* calibration_curve,
    int num_fixes, SPAposition* fix_positions, double*
    fix_radii, var_radius*& rad_obj, double* start_slope= NULL,
    double* end_slope= NULL, AcisOptions* ao = NULL);

outcome api_make_radius_rnd_chamfer(double start_left_off,
    double end_left_off, double start_right_off, double end_right_off,
    var_radius*& rad_obj1, var_radius*& rad_obj2, AcisOptions* ao
    = NULL);

outcome api_make_radius_rot_ellipse(double maj_start, double
    maj_end, double min_start, double min_end, double ang_start, double ang_end,
    logical ref_face_left, var_radius*& rad_obj, AcisOptions* ao
    = NULL);

outcome api_make_radius_spline_rad( bs3_curve rad_spl,
var_radius*& rad_obj, CURVE* calibration_curve= NULL, logical
edge_periodic= FALSE, AcisOptions* ao = NULL);

outcome api_make_radius_two_ends(double start_rad, double
end_rad, var_radius*& rad_obj, AcisOptions* ao = NULL);

outcome api_make_rails( ENTITY* path, law**&
    rails, int& number_of_rails, law** axis= NULL,
    FACE** faces= NULL, law** user_rails= NULL, law*
    twist_law= NULL, AcisOptions* ao = NULL);

outcome api_make_root_state( DELTA_STATE* ds);

outcome api_make_spface(const SPAposition& center, double
    radius, const SPAunit_vector& lat, const SPAunit_vector& lon,
    double slat, double elat, double slon, double elon, FACE*& face,
    AcisOptions* ao = NULL);

outcome api_make_sphere(double radius, BODY*& body,
AcisOptions* ao = NULL);

outcome api_make_spline( spline const& this_spline,
BODY*& body, AcisOptions* ao = NULL);

outcome api_make_torus(double major_radius, double minor_radius,
BODY*& body, AcisOptions* ao = NULL);

outcome api_make_trface(const SPAposition& center, const
    SPAunit_vector& normal, double major, double minor, const SPAposition& pnt,
    double uf, double ut, double vf, double vt, FACE*& face,
    AcisOptions* ao = NULL);

outcome api_make_VBL_output_surfaces(const surface* vbl_sf,
double& interior_fit, double& boundary_fit, bs3_surface*&
bs3_array, int& n, logical approx_error= TRUE);

outcome api_make_version_object( AcisVersion*& av, int
tag);

outcome api_make_wire( BODY* given_body, int length_pts,
SPAposition array_pts[], BODY*& body, AcisOptions* ao
= NULL);

outcome api_make_wires_sli( AcisSLInterface* obj,
ENTITY_LIST& wire_list, AcisOptions* opts = NULL);

outcome api_manifold_class( BODY* given_body,
    ENTITY_LIST*& mani_shells, ENTITY_LIST*& mani_sheets,
    ENTITY_LIST& wire_edges, ENTITY_LIST& lamina_faces,
    ENTITY_LIST*& edge_arcs, ENTITY_LIST*& vertex_arcs, AcisOptions*
    ao = NULL);

outcome api_mark_faceted_faces(logical mark, AcisOptions* ao
= NULL);

outcome api_merge_faces( BODY* tool, int& geom_type,
AcisOptions* ao = NULL);

outcome api_merge_states( DELTA_STATE* ds1= NULL,
DELTA_STATE* ds2= NULL, HISTORY_STREAM* hs= NULL, logical
prune_partners= FALSE, logical keep_both= FALSE);

outcome api_minimize_twist_wires_sli( AcisSLInterface* obj,
int start= 0, int end= 0, AcisOptions* opts = NULL);

outcome api_mk_by_faces( BODY* given_body, int num_faces,
FACE* faces[], BODY*& body, AcisOptions* ao =
NULL);

outcome api_mk_ed_bs3_curve( bs3_curve bs, EDGE*& edge,
AcisOptions* ao = NULL);

outcome api_mk_ed_conic(const SPAposition& start, const
SPAunit_vector& start_tan, const SPAposition& end, const SPAunit_vector&
end_tan, double rho, EDGE*& edge, AcisOptions* ao = NULL);

outcome api_mk_ed_cubic(int npts, const SPAposition
pts[], SPAunit_vector const& start_dir, SPAunit_vector const&
end_dir, double fitol, EDGE*& edge, AcisOptions* ao = NULL);

outcome api_mk_ed_ellipse( SPAposition const& center,
    SPAunit_vector const& normal, SPAvector const& major_axis, double
    radius_ratio, double start_angle, double end_angle, EDGE*& edge,
    AcisOptions* ao = NULL);

outcome api_mk_ed_int_ctrlpts(int degree, logical rational,
    logical closed, logical periodic, int num_ctrlpts, const SPAposition
    ctrlpts[], const double weights[], double point_tol, int num_knots,
    const double knots[], double knot_tol, EDGE*& edge,
    AcisOptions* ao = NULL);

outcome api_mk_ed_line( SPAposition const& start_point,
SPAposition const& end_point, EDGE*& edge, AcisOptions* ao
= NULL);

outcome api_mk_fa_spl_ctrlpts(int degree_u, logical rational_u,
    int form_u, int pole_u, int num_ctrlpts_u, int degree_v, logical
    rational_v, int form_v, int pole_v, int num_ctrlpts_v, const SPAposition
    ctrlpts[], const double weights[], double point_tol, int num_knots_u,
    const double knots_u[], int num_knots_v, const double
    knots_v[], double knot_tol, FACE*& face, AcisOptions* ao =
    NULL);

outcome api_mk_fa_spl_fit(double fittol, int num_pts_u, int
    num_pts_v, const SPAposition pts[], const SPAunit_vector
    du_s[], const SPAunit_vector du_e[], FACE*& face,
    AcisOptions* ao = NULL);

outcome api_mk_fa_spl_intp(int num_pts_u, int num_pts_v, const
    SPAposition pts[], const SPAunit_vector du_s[], const
    SPAunit_vector du_e[], const SPAunit_vector dv_s[], const
    SPAunit_vector dv_e[], FACE*& face, AcisOptions* ao =
    NULL);

outcome api_modify_ellipse( EDGE* ell, const SPAposition&
    center, const SPAunit_vector& normal, const SPAvector&
    major_axis, double radius_ratio, double start_angle, double end_angle,
    AcisOptions* ao = NULL);

outcome api_modify_line( EDGE* line, const SPAposition&
st_pt, const SPAposition& end_pt, AcisOptions* ao = NULL);

outcome api_modify_refinement( REFINEMENT* ref, double
    flatness= 0.0, double aspect_ratio= 0.0, double surtol= 0.0,
    double nortol= 15.0, double siltol= 0.0, double pixtol= 0.0,
    int min_level= 0, int max_level= 0, int mode = 0,
    AcisOptions* ao = NULL);

outcome api_modify_vertex_template(int n_tokens, int*
tokens[], VERTEX_TEMPLATE* tplate, AcisOptions* ao = NULL);

outcome api_modify_wire_sli( AcisSLInterface* obj,
COEDGE* coedge1, COEDGE* coedge2, SPAposition adjusted_point,
WIRE* wire, AcisOptions* opts = NULL);

outcome api_move_edge( EDGE* edge, double dist, logical extend
= TRUE, AcisOptions* ao= NULL);

outcome api_move_faces(int const nface, FACE* face[],
SPAtransf const& tr, SPAposition box_low, SPAposition box_high,
AcisOptions* ao = NULL);

outcome api_move_vertex_sli( AcisSLInterface* obj,
COEDGE* coedge1, COEDGE* coedge2, SPAposition pos, WIRE* wire,
AcisOptions* opts = NULL);

outcome api_name_state(const char* name, DELTA_STATE* ds
);

outcome api_ndifferentiate_law( law* input_law, double*
where, int which_dim, double* answer, int type= 0, int times= 1
);

outcome api_net_sections(int nv_sect,
    Loft_Connected_Coedge_List** v_sects, int nu_sect, Loft_Connected_Coedge_List**
    u_sects, BODY*& out_body, logical simplify= FALSE, double
    net_tol= SPAresfit, AcisOptions* ao = NULL);

outcome api_net_wires(int num_v_wires, BODY*
    v_wires[], int num_u_wires, BODY* u_wires[], BODY*&
    sheet_body, skin_options* opts, double net_tol= SPAresfit,
    AcisOptions* ao = NULL);

outcome api_nmax_of_law( law* input_law, double start, double
end, double* answer);

outcome api_nmin_of_law( law* input_law, double start, double
end, double* answer);

outcome api_note_state( DELTA_STATE*& ds,
HISTORY_STREAM* hs= NULL, logical delete_if_empty= FALSE);

outcome api_nroots_of_law( law* input_law, double start,
double end, int* size, double** answer);

outcome api_nsolve_laws( law* input_law1, law*
input_law2, double start, double end, int* size, double** answer);

outcome api_offset_body( BODY* body, double offset,
SPAposition box_low, SPAposition box_high, AcisOptions* ao = NULL);

outcome api_offset_face( FACE* given_face, double
offset_distance, FACE*& offset_face, AcisOptions* ao = NULL);

outcome api_offset_faces(int const nface, FACE*
face[], double offset, SPAposition box_low, SPAposition box_high,
AcisOptions* ao = NULL);

outcome api_offset_faces_make_sheet(int const& n_def_face,
    FACE* def_face[], double def_offset, int const&
    n_spec_face, FACE* spec_face[], double spec_offset[],
    BODY*& sheet_body, SPAposition box_low, SPAposition box_high,
    AcisOptions* ao= NULL);

outcome api_offset_faces_specific(int const& n_def_face,
    FACE* def_face[], double def_offset, int const&
    n_spec_face, FACE* spec_face[], double spec_offset[],
    SPAposition box_low, SPAposition box_high, AcisOptions* ao = NULL);

outcome api_offset_planar_face_loops( FACE* in_face, double
offset_dist, BODY*& outbody, sg_gap_type gap= arc,
AcisOptions* ao = NULL);

outcome api_offset_planar_wire( BODY* given_wire, law*
    offset_law, law* twist_law, const SPAunit_vector&wire_normal,
    BODY*& offset_wire, int gap_type= 2, logical trim= TRUE, logical
    overlap= FALSE, AcisOptions* ao = NULL);

outcome api_optimize_tvertex_tolerance( EDGE* this_edge,
AcisOptions* ao= NULL);

outcome api_part_add_entity( ENTITY* entity, PART* part);

outcome api_part_create(unsigned int, PART*& part);

outcome api_part_delete( PART* part);

outcome api_part_delete_all_states( HISTORY_STREAM* hs=
NULL);

outcome api_part_entities( PART* part, entity_filter*
filter, ENTITY_LIST& list);

outcome api_part_entity_id( ENTITY* entity, entity_id_t&
id, PART*& part);

outcome api_part_get_distribution_mode(logical& distribute
);

outcome api_part_load(FILE* fp, logical text_mode, PART*
the_part, logical with_history, ENTITY_LIST& new_entities);

outcome api_part_lookup_entity( entity_id_t id, PART* part,
ENTITY*& entity);

outcome api_part_name_state(const char* name,
HISTORY_STREAM* hs= NULL);

outcome api_part_note_state( outcome status, int& depth);

outcome api_part_remove_entity( ENTITY* entity);

outcome api_part_roll_n_states(int n_wanted,
HISTORY_STREAM* hs, int& n_actual);

outcome api_part_roll_to_state(const char* name,
HISTORY_STREAM* hs, int& n_actual);

outcome api_part_save(FILE* fp, logical text_mode, PART*
the_part, logical with_history= 0, logical mainline_only= 0);

outcome api_part_set_distribution_mode(logical distribute);

outcome api_part_start_state(int& depth);

outcome api_pattern_find_bump(const ENTITY* seed,
    ENTITY_LIST& face_list, ENTITY_LIST& loop_list, ENTITY_LIST&
    no_cross_list=*(ENTITY_LIST*)NULL_REF, AcisOptions* ao =
    NULL);

outcome api_pattern_to_entity( pattern* in_pat,
ENTITY*& out_ent, AcisOptions* ao = NULL);

outcome api_pause_journal( AcisOptions* ao);

outcome api_periodic_keep_pattern( pattern*& pat, const
pattern& in_pattern, const logical* keep, int period, int which_dim,
logical merge= TRUE, AcisOptions* ao = NULL);

outcome api_periodic_scale_pattern( pattern*& pat, const
    pattern& in_pattern, const double* scale, int period, int which_dim,
    const SPAposition& root, logical merge= TRUE, AcisOptions*
    ao = NULL);

outcome api_phlv5_clean( ENTITY_LIST const& bodies, int token,
AcisOptions* ao = NULL);

outcome api_phlv5_compute( ENTITY_LIST const& bodies, int
    token, SPAposition const& eyepos, SPAposition const& target,
    logical persp, ENTITY_LIST& edges, phlv5_options* phlv5_opts
    = NULL, AcisOptions* ao = NULL);

outcome api_phlv5_retrieve( ENTITY_LIST const& bodies, int
token, ENTITY_LIST& hed_list, PHLV5_CAMERA*& camera,
AcisOptions* ao = NULL);

outcome api_phl_clean( ENTITY_LIST const& bodies, int token);

outcome api_phl_compute( ENTITY_LIST const& bodies, int token,
SPAposition const& eyepos, SPAposition const& target, logical persp,
ENTITY_LIST& edges);

outcome api_phl_retrieve( ENTITY_LIST const& bodies, int
token, ENTITY_LIST& edges, PHL_CAMERA*& camera);

outcome api_phl_set_cell_factor(double cell_factor);

outcome api_phl_set_curve_resolution(double crv_res);

outcome api_phl_set_occlusion(logical occ);

outcome api_phl_set_shooting(double shooting);

outcome api_phl_set_smooth_angle(double angle);

outcome api_phl_show_cell_factor(double& cell_factor);

outcome api_phl_show_curve_resolution(double&
curve_resolution);

outcome api_phl_show_occlusion(logical& occ);

outcome api_phl_show_shooting(double& shooting);

outcome api_pidget( ENTITY* given_entity, const
pid_base*& pid, AcisOptions* ao = NULL);

outcome api_pidrem( ENTITY* given_entity, AcisOptions* ao
= NULL);

outcome api_pidset( ENTITY* given_entity, AcisOptions* ao
= NULL);

outcome api_pierce_sheet( BODY* big, BODY* small,
FACE*& face, AcisOptions* ao = NULL);

outcome api_planar_face_pr( FACE* face, double req_rel_accy,
    double& area, SPAposition& centre, double& moment_a, double&
    moment_b, SPAunit_vector& axis_a, SPAunit_vector& axis_b,
    double& est_rel_accy_achieved, AcisOptions* ao = NULL);

outcome api_planar_slice( BODY* ent, const SPAposition&
pt, const SPAunit_vector& normal, BODY*& slice,
AcisOptions* ao = NULL);

outcome api_pm_add_entity( ENTITY* entity, PART* part);

outcome api_pm_create_part(unsigned int, PART*& part);

outcome api_pm_delete_all_states( HISTORY_STREAM* hs=
NULL);

outcome api_pm_delete_part( PART* part);

outcome api_pm_entity_id( ENTITY* ent, entity_id_t& id,
PART*& part);

outcome api_pm_load_part(FILE* fp, logical text_mode,
PART* the_part, logical with_history, ENTITY_LIST& new_entities);

outcome api_pm_lookup_entity( entity_id_t id, PART* part,
ENTITY*& ent);

outcome api_pm_name_state(const char* name,
HISTORY_STREAM* hs= NULL);

outcome api_pm_note_state( outcome out, int& depth);

outcome api_pm_part_entities( PART* part, entity_filter*
filter, ENTITY_LIST& ent);

outcome api_pm_remove_entity( ENTITY* entity);

outcome api_pm_roll_n_states(int n_wanted, HISTORY_STREAM*
hs, int& n_actual);

outcome api_pm_roll_to_state(const char* name,
HISTORY_STREAM* hs, int& n_actual);

outcome api_pm_save_part(FILE* fp, logical text_mode,
PART* the_part, logical with_history= 0, logical mainline_only=
0);

outcome api_pm_start_state(int& depth);

outcome api_point_in_body( SPAposition const& test_point,
BODY* target_body, point_containment& pc, logical use_boxes =
TRUE, AcisOptions* ao = NULL);

outcome api_point_in_face( SPAposition const& test_point,
    FACE* test_face, SPAtransf const& face_trans,
    point_face_containment& cont_answer, SPApar_pos const& test_uv_guess, SPAposition
    const& prev_point_input, point_face_containment prev_cont, logical
    use_cache, int cache_size, AcisOptions* ao);

outcome api_polar_grid_pattern( pattern*& pat, const
    SPAposition& center, const SPAvector& normal, int num_rings, double
    distance, const SPAvector& start=*(SPAvector*)NULL_REF,
    logical not_rotate= FALSE, logical hex_symmetry= FALSE, double
    start_angle= 0.0, double end_angle= 2.0* 3.14159265358979323846,
    double ratio= 1.0, AcisOptions* ao = NULL);

outcome api_preview_blends( BODY* blank_body, BODY*&
sheet_body, ENTITY_LIST const&blend_atts, ENTITY_LIST&
cannot_preview, AcisOptions* ao= NULL);

outcome api_project_curve_to_surface(const curve& in_curve,
const SPAinterval& in_range, const surface& in_surface,
curve*& curve_on_surface, AcisOptions* ao = NULL);

outcome api_project_wire( BODY* wire_body, BODY* body,
const SPAunit_vector& dir, double dist, AcisOptions* ao =
NULL);

outcome api_prune_following( HISTORY_STREAM* hs);

outcome api_prune_history( HISTORY_STREAM* hs,
DELTA_STATE* ds= NULL);

outcome api_ptent_rel( APOINT* point, ENTITY* entity,
point_entity_rel*& rel, AcisOptions* ao = NULL);

outcome api_query_state_validity( DELTA_STATE* ds,
logical& change_state_possible, HISTORY_STREAM* hs= NULL);

outcome api_q_edges_around_vertex( VERTEX* vertex,
ENTITY_LIST* edge_list, AcisOptions* ao = NULL);

outcome api_radial_pattern( pattern*& pat, const
    SPAposition& center, const SPAvector& normal, int num_radial, int
    num_angular, double spacing, const SPAvector& start
    =*(SPAvector*)NULL_REF, logical not_rotate= FALSE, double start_angle= 0.0, double
    end_angle= 2.0* 3.14159265358979323846, double ratio= 1.0,
    AcisOptions* ao = NULL);

outcome api_random_keep_pattern( pattern*& pat, const
pattern& in_pattern, double keep_fraction, logical merge= TRUE,
AcisOptions* ao = NULL);

outcome api_random_offset_pattern( pattern*& pat, const
pattern& in_pat, const SPAvector& amplitude, AcisOptions* ao =
NULL);

outcome api_random_orient_pattern( pattern*& pat, const
    pattern& in_pat, const SPAposition& root= SPAposition(0, 0, 0),
    const SPAinterval& axial_range= SPAinterval(0.0, 2.0*
    3.14159265358979323846), const SPAvector& axial_dir
    =*(SPAvector*)NULL_REF, const SPAinterval& tilt_range= SPAinterval(0,
    3.14159265358979323846), const SPAvector& tilt_dir
    =*(SPAvector*)NULL_REF, AcisOptions* ao = NULL);

outcome api_random_pattern( pattern*& pat, const
    SPAvector& extents, int num_elements, int dimension= 3, logical
    ellipsoidal= FALSE, const SPAvector& x_vec= SPAvector(1, 0, 0),
    const SPAvector& y_vec= SPAvector(0, 1, 0), AcisOptions* ao
    = NULL);

outcome api_random_scale_pattern( pattern*& pat, const
pattern& in_pattern, double min_scale, double max_scale, const
SPAposition& root, logical merge = TRUE, AcisOptions* ao = NULL);

outcome api_raytest_body( SPAposition const& ray_point,
    SPAunit_vector const&ray_direction, double ray_radius, int hits_wanted,
    BODY* target_body, hit*& hit_list, AcisOptions* ao =
    NULL);

outcome api_raytest_ents( SPAposition const& ray_point,
    SPAunit_vector const&ray_direction, double ray_radius, int hits_wanted, int
    n_target_ents, ENTITY* target_ents[], hit*& hit_list,
    AcisOptions* ao = NULL);

outcome api_ray_test_body( SPAposition const& ray_point,
    SPAunit_vector const&ray_direction, double ray_radius, int hits_wanted,
    BODY* target_body, ENTITY_LIST& entities_hit, double*&
    ray_parameters, AcisOptions* ao = NULL);

outcome api_ray_test_ents( SPAposition const& ray_point,
    SPAunit_vector const&ray_direction, double ray_radius, int hits_wanted, int
    n_target_ents, ENTITY* target_ents[], ENTITY_LIST&
    entities_hit, double*& ray_parameters, AcisOptions* ao = NULL);

outcome api_reenter_coedges_li(int number_coedges,
Loft_Connected_Coedge_List*edgeList, AcisLoftingInterface* obj, BODY**&
wireBodies, AcisOptions* opts = NULL);

outcome api_refresh_entity_pattern( ENTITY* in_ent,
    ENTITY_LIST& refresh_list, pattern* in_pat, logical copy_pat= TRUE, int
    seed_index= 0, ENTITY_LIST& no_cross_faces
    =*(ENTITY_LIST*)NULL_REF, PAT_CHECK_TYPE check= PAT_DONT_CHECK, AcisOptions* ao
    = NULL);

outcome api_regularise_entity( ENTITY* ent, AcisOptions*
ao = NULL);

outcome api_remove_and_repair_body(int const nface, FACE*
faces[], SPAposition box_low, SPAposition box_high, AcisOptions* ao
= NULL);

outcome api_remove_face( FACE* given_face, AcisOptions*
ao = NULL);

outcome api_remove_faces(int const nface, FACE*
face[], SPAposition box_low, SPAposition box_high, AcisOptions* ao
= NULL);

outcome api_remove_generic_named_attribute( ENTITY* ent,
const char* name, AcisOptions* ao = NULL);

outcome api_remove_lop_attribs( ENTITY* entity,
AcisOptions* ao = NULL);

outcome api_remove_mapping_curve_sli( AcisSLInterface* obj,
int index, AcisOptions* opts = NULL);

outcome api_remove_no_merge_attrib( ENTITY_LIST& list,
AcisOptions* ao = NULL);

outcome api_remove_pattern( ENTITY* ent, AcisOptions* ao
= NULL);

outcome api_remove_state( DELTA_STATE* ds);

outcome api_remove_transf( ENTITY* entity, AcisOptions*
ao = NULL);

outcome api_remove_vertex_sli( AcisSLInterface* obj,
WIRE* wire, SPAposition pos, AcisOptions* opts = NULL);

outcome api_remove_wire_edge( EDGE* given_edge,
AcisOptions* ao = NULL);

outcome api_repair_body_self_ints( BODY* body, int const
nface, FACE* faces[], AcisOptions* ao= NULL);

outcome api_replace_edge_with_tedge( EDGE* this_edge,
TEDGE*& this_tedge, AcisOptions* ao = NULL);

outcome api_replace_edge_with_tvertex( ENTITY_LIST&
edgeList, ENTITY_LIST& tVertex_list, AcisOptions* ao = NULL);

outcome api_replace_face_with_tedge( FACE* face,
ENTITY_LIST& tedges, AcisOptions* ao = NULL);

outcome api_replace_tedge_with_edge( TEDGE* this_tedge,
EDGE*& this_edge, AcisOptions* ao = NULL);

outcome api_replace_tvertex_with_vertex( TVERTEX*
this_tvertex, VERTEX*& this_vertex, AcisOptions* ao = NULL);

outcome api_replace_vertex_with_tvertex( VERTEX*
this_vertex, TVERTEX*& this_tvertex, AcisOptions* ao = NULL);

outcome api_reset_boxes( ENTITY* ent, AcisOptions* ao
= NULL);

outcome api_restore_entity_list(FILE* file_ptr, logical
text_mode, ENTITY_LIST& entities, AcisOptions* ao = NULL);

outcome api_restore_entity_list_file( FileInterface*
file_ptr, ENTITY_LIST& entities, AcisOptions* ao = NULL);

outcome api_restore_entity_list_with_history(FILE*
    file_ptr, logical text_mode, ENTITY_LIST& entities,
    HISTORY_STREAM_LIST& hslist, DELTA_STATE_LIST& dslist, AcisOptions* ao =
    NULL);

outcome api_restore_entity_list_with_history_file(
FileInterface* file_ptr, ENTITY_LIST& entities, HISTORY_STREAM_LIST&
hslist, DELTA_STATE_LIST& dslist, AcisOptions* ao = NULL);

outcome api_restore_history(FILE* file_ptr, logical
text_mode, HISTORY_STREAM_LIST& hlist, logical create_new_hs=
FALSE, AcisOptions* ao = NULL);

outcome api_restore_history_file( FileInterface* file_ptr,
HISTORY_STREAM_LIST& hlist, logical create_new_hs= FALSE, AcisOptions* ao =
NULL);

outcome api_resume_journal( AcisOptions* ao);

outcome api_reverse_body( BODY* body, AcisOptions* ao
= NULL);

outcome api_reverse_face( FACE*& face, AcisOptions*
ao = NULL);

outcome api_reverse_wire( WIRE* wire, AcisOptions* ao
= NULL);

outcome api_rh_convert_image_end();

outcome api_rh_convert_image_start( LwInt32 width, LwInt32 height
);

outcome api_rh_convert_rgb_float_scanline( LwFloat* input,
LwInt32* output);

outcome api_rh_convert_rgb_scanline( LwNat8* input,
LwInt32* output);

outcome api_rh_copy_background( RH_BACKGROUND* background,
RH_BACKGROUND*& new_background);

outcome api_rh_copy_foreground( RH_FOREGROUND* foreground,
RH_FOREGROUND*& new_foreground);

outcome api_rh_copy_light( RH_LIGHT* light,
RH_LIGHT*& new_light);

outcome api_rh_copy_material( RH_MATERIAL* material,
RH_MATERIAL*& new_material);

outcome api_rh_copy_texture_space( RH_TEXTURE_SPACE*
texture_space, RH_TEXTURE_SPACE*&new_texture_space);

outcome api_rh_create_background(const char* name,
RH_BACKGROUND*& background);

outcome api_rh_create_cube_environment(unsigned char*, int
channels, int width[], int height[], Image_Access_Function
afunc, RH_ENVIRONMENT_MAP*& env_map);

outcome api_rh_create_foreground(const char* name,
RH_FOREGROUND*& foreground);

outcome api_rh_create_light(const char* name,
RH_LIGHT*& light);

outcome api_rh_create_light_shadow( RH_LIGHT* light,
ENTITY_LIST const& entities);

outcome api_rh_create_material( RH_MATERIAL*& material
);

outcome api_rh_create_texture_space(const char* name,
RH_TEXTURE_SPACE*&texture_space);

outcome api_rh_def_color_comp(const char* name);

outcome api_rh_def_displace_comp(const char* name);

outcome api_rh_def_reflect_comp(const char* name);

outcome api_rh_def_transp_comp(const char* name);

outcome api_rh_delete_background( RH_BACKGROUND* background
);

outcome api_rh_delete_environment_map( RH_ENVIRONMENT_MAP*
environment_map);

outcome api_rh_delete_foreground( RH_FOREGROUND* foreground
);

outcome api_rh_delete_light( RH_LIGHT* light);

outcome api_rh_delete_light_shadow( RH_LIGHT* light);

outcome api_rh_delete_material( RH_MATERIAL* material);

outcome api_rh_delete_texture_space( RH_TEXTURE_SPACE*
texture_space);

outcome api_rh_display_image( LwInt32 width, LwInt32 height,
    LwDisplayMethod method, LwInt32 n_colours, void(* input_scanline)(LwInt32 y,
    LwNat8** scan), void(* output_scanline)(LwInt32 y, LwInt32* scan),
    void(* set_colour_map)(LwNat8* colours));

outcome api_rh_get_background( RH_BACKGROUND*&
background// to be queried);

outcome api_rh_get_background_args( RH_BACKGROUND*
background, const char*& name, int& no_of_args, const
char** arg_names&, Render_Arg*& arg_values);

outcome api_rh_get_background_types(int& n_backgrounds,
const char**& names);

outcome api_rh_get_clipping(double& near_clipping_plane,
double& far_clipping_plane);

outcome api_rh_get_color_comp( RH_MATERIAL* material, const
char*& name, int& no_of_args, const char** arg_names&,
Render_Arg*& arg_values);

outcome api_rh_get_color_comp_list(int& n_colors, const
char**& names);

outcome api_rh_get_control_variable( Render_Control_Var var,
Render_Arg& variable);

outcome api_rh_get_default_rgb( rgb_color& color);

outcome api_rh_get_displace_comp( RH_MATERIAL* material,
const char*& name, int& no_of_args, const char**
arg_names&, Render_Arg*& arg_values);

outcome api_rh_get_displace_comp_list(int& n_displaces,
const char**& names);

outcome api_rh_get_displace_status( RH_MATERIAL* material,
logical& status);

outcome api_rh_get_entity_rgb( ENTITY* ent, rgb_color&
color, logical inherit, logical& found);

outcome api_rh_get_environment_map(
RH_ENVIRONMENT_MAP*& emap);

outcome api_rh_get_foreground( RH_FOREGROUND*&
foreground);

outcome api_rh_get_foreground_args( RH_FOREGROUND*
foreground, const char*& name, int& no_of_args, const
char** arg_names&, Render_Arg*& arg_values);

outcome api_rh_get_foreground_types(int& n_foregrounds,
const char**& names);

outcome api_rh_get_highlight_rgb( rgb_color& color);

outcome api_rh_get_light_args( RH_LIGHT* light, const
char*& name, int& no_of_args, const char** arg_names&,
Render_Arg*& arg_values);

outcome api_rh_get_light_list( ENTITY_LIST& lights);

outcome api_rh_get_light_state( RH_LIGHT* light,
logical* on_off);

outcome api_rh_get_light_types(int& n_types, const
char**& names);

outcome api_rh_get_material( ENTITY* entity,
RH_MATERIAL*& material);

outcome api_rh_get_material_color( ENTITY* entity,
double& red, double& green, double& blue);

outcome api_rh_get_material_reflection( ENTITY* entity,
double& ambient, double& diffuse, double& specular, double&
exponent);

outcome api_rh_get_material_texture( ENTITY* entity, const
char*& tex_name);

outcome api_rh_get_material_transp( ENTITY* entity_list,
double& transp);

outcome api_rh_get_output_mode( Output_Mode& output_mode);

outcome api_rh_get_reflect_comp( RH_MATERIAL* material,
const char*& name, int& no_of_args, const char**
arg_names&, Render_Arg*& arg_values);

outcome api_rh_get_reflect_comp_list(int& n_reflects, const
char**& names);

outcome api_rh_get_reflect_status( RH_MATERIAL* material,
logical& status);

outcome api_rh_get_render_mode( Render_Mode& render_mode);

outcome api_rh_get_resolution(int& width, int& height,
double& pixel_aspect_ratio, double& image_scale);

outcome api_rh_get_sidedness( ENTITY* entity, int& sides
);

outcome api_rh_get_sub_image(int& left, int& right,
int& top, int& bottom);

outcome api_rh_get_texture_space( ENTITY* entity,
RH_TEXTURE_SPACE*&texture_space);

outcome api_rh_get_texture_space_args( RH_TEXTURE_SPACE*
texture_space, const char*& name, int& no_of_args, const
char** arg_names&, Render_Arg*& arg_values);

outcome api_rh_get_texture_space_types(int& n_types, const
char**& names);

outcome api_rh_get_transp_comp( RH_MATERIAL* material, const
char*& name, int& no_of_args, const char** arg_names&,
Render_Arg*& arg_values);

outcome api_rh_get_transp_comp_list(int& n_transparencies,
const char**& names);

outcome api_rh_get_transp_status( RH_MATERIAL* material,
logical& status);

outcome api_rh_get_view( SPAposition& from_point,
SPAposition& to_point, SPAvector& view_up_vector, Projection_Type&
projection, double& field_of_view);

outcome api_rh_initialise();

outcome api_rh_initialise_image_utilities();

outcome api_rh_initialise_supl_shaders();

outcome api_rh_read_lightworks_image(FILE* fp, LwInt32
channels, LwInt32 width, LwInt32 height, LwNat8* data);

outcome api_rh_read_lightworks_image_size(FILE* fp,
LwInt32* width, LwInt32* height);

outcome api_rh_render_cube_environment( ENTITY_LIST const&
entities, int resolution, SPAposition const& view_point,
RH_ENVIRONMENT_MAP*& env_map);

outcome api_rh_render_entities( ENTITY_LIST const& entities,
logical clear_screen= TRUE);

outcome api_rh_set_background( RH_BACKGROUND* background);

outcome api_rh_set_background_arg( RH_BACKGROUND*
background, const char* arg_name, const Render_Arg& value);

outcome api_rh_set_clipping(double near_clipping_plane, double
far_clipping_plane);

outcome api_rh_set_color_arg( RH_MATERIAL* material, const
char* arg_name, const Render_Arg& value);

outcome api_rh_set_color_comp( RH_MATERIAL* material, const
char* color_shader_name);

outcome api_rh_set_control_variable( Render_Control_Var var,
const Render_Arg& value);

outcome api_rh_set_conversion_colour_map( LwInt32 r_max, LwInt32
g_max, LwInt32 b_max, LwInt32 r_mult, LwInt32 g_mult, LwInt32 b_mult,
LwInt32 base_index);

outcome api_rh_set_conversion_method( LwConversionMethod method
);

outcome api_rh_set_default_rgb( rgb_color color);

outcome api_rh_set_displace_arg( RH_MATERIAL* material,
const char* arg_name, const Render_Arg& value);

outcome api_rh_set_displace_comp( RH_MATERIAL* material,
const char* name);

outcome api_rh_set_displace_status( RH_MATERIAL* material,
logical status);

outcome api_rh_set_entity_rgb( ENTITY* ent, rgb_color color);

outcome api_rh_set_environment_map( RH_ENVIRONMENT_MAP*
emap);

outcome api_rh_set_foreground( RH_FOREGROUND* foreground);

outcome api_rh_set_foreground_arg( RH_FOREGROUND*
foreground, const char* arg_name, const Render_Arg& value);

outcome api_rh_set_highlight_rgb( rgb_color color);

outcome api_rh_set_light_arg( RH_LIGHT* light, const
char* arg_name, const Render_Arg& value);

outcome api_rh_set_light_list( ENTITY_LIST const& lights);

outcome api_rh_set_light_state( RH_LIGHT* light, logical
on_off);

outcome api_rh_set_material( ENTITY_LIST const&entities,
RH_MATERIAL* material=(RH_MATERIAL*)NULL);

outcome api_rh_set_material_color( ENTITY_LIST const&
entities, double red, double green, double blue);

outcome api_rh_set_material_reflection( ENTITY_LIST const&
entity_list, double ambient, double diffuse, double specular, double exponent);

outcome api_rh_set_material_texture( ENTITY_LIST const&
entity_list, const char* tex_name);

outcome api_rh_set_material_transp( ENTITY_LIST const&
entity_list, double transp);

outcome api_rh_set_output_mode( Output_Mode output_mode);

outcome api_rh_set_reflect_arg( RH_MATERIAL* material, const
char* arg_name, const Render_Arg& value);

outcome api_rh_set_reflect_comp( RH_MATERIAL* material,
const char*reflectance_shader_name);

outcome api_rh_set_reflect_status( RH_MATERIAL* material,
logical status);

outcome api_rh_set_render_mode( Render_Mode render_mode);

outcome api_rh_set_resolution(int width, int height, double
pixel_aspect_ratio, double image_scale);

outcome api_rh_set_sidedness( ENTITY_LIST const&entities,
int sides);

outcome api_rh_set_sub_image(int left, int right, int top, int
bottom);

outcome api_rh_set_texture_space( ENTITY_LIST const&
entities, RH_TEXTURE_SPACE*texture_space
=(RH_TEXTURE_SPACE*)NULL);

outcome api_rh_set_texture_space_arg( RH_TEXTURE_SPACE*
texture_space, const char* arg_name, const Render_Arg& value);

outcome api_rh_set_transp_arg( RH_MATERIAL* material, const
char* arg_name, const Render_Arg& value);

outcome api_rh_set_transp_comp( RH_MATERIAL*material, const
char*transparency_shader_name);

outcome api_rh_set_transp_status( RH_MATERIAL* material,
logical status);

outcome api_rh_set_view( SPAposition from_point, SPAposition
to_point, SPAvector view_up_vector, Projection_Typeprojection, double
field_of_view);

outcome api_rh_terminate();

outcome api_rh_terminate_image_utilities();

outcome api_roll_n_states( HISTORY_STREAM* hs, int nRequest,
int& nActual);

outcome api_rsw_face_path( FACE* sw_face, logical which_side,
COEDGE* path, sweep_options* opts= NULL);

outcome api_rsw_face_vec( FACE* sw_face, logical which_side,
const SPAvector& sw_vec, sweep_options* opts= NULL);

outcome api_rsw_wire_path( BODY* wire_body, COEDGE* path,
sweep_options* opts= NULL);

outcome api_rsw_wire_vec( BODY* wire_body, const
SPAvector& sw_vec, sweep_options* opts= NULL);

outcome api_save_entity_list(FILE* file_ptr, logical
text_mode, ENTITY_LIST const&entity_list, AcisOptions* ao = NULL
);

outcome api_save_entity_list_file( FileInterface* file_ptr,
ENTITY_LIST const& entity_list, AcisOptions* ao = NULL);

outcome api_save_entity_list_with_history(FILE* file_ptr,
    logical text_mode, ENTITY_LIST const&entity_list,
    HISTORY_STREAM_LIST& hslist, DELTA_STATE_LIST& dslist, AcisOptions* ao =
    NULL);

outcome api_save_entity_list_with_history_file(
    FileInterface* file_ptr, ENTITY_LIST const& entity_list,
    HISTORY_STREAM_LIST& hslist, DELTA_STATE_LIST& dslist, logical mainline_only =
    FALSE, AcisOptions* ao = NULL);

outcome api_save_history(FILE* file_ptr, logical text_mode,
HISTORY_STREAM* hs= NULL, logical active_ents_only= FALSE, logical
mainline_only= FALSE, AcisOptions* ao = NULL);

outcome api_save_history_file( FileInterface* file_ptr,
HISTORY_STREAM* hs= NULL, logical active_ents_only= FALSE, logical
mainline_only= FALSE, AcisOptions* ao = NULL);

outcome api_save_state(FILE* file_ptr, AcisOptions* ao
= NULL);

outcome api_save_version(int major_version, int minor_version);

outcome api_selectively_imprint( BODY* tool,
    ENTITY_LIST& tool_faces, BODY* blank, ENTITY_LIST& blank_faces,
    logical split_checking= TRUE, ENTITY_LIST& intgraph_edges
    =*(ENTITY_LIST*)NULL_REF, AcisOptions* ao = NULL);

outcome api_selectively_intersect(const int number_faces,
FACE* tool_faces[], FACE* blank_faces[],
AcisOptions* ao = NULL);

outcome api_selective_boolean_stage1( BODY* blank, BODY*
tool, generic_graph*& graph, AcisOptions* ao = NULL);

outcome api_selective_boolean_stage2( BODY*
non_reg_unite_body, ENTITY_LIST& cells_to_keep, AcisOptions* ao = NULL);

outcome api_selective_unite( BODY* tool, BODY* blank, int
tnum, SPAposition* tpos, int bnum= 0, SPAposition* bpos =
NULL, AcisOptions* ao = NULL);

outcome api_separate_body( BODY* in_body, int& nbody,
BODY**& bodylist, AcisOptions* ao = NULL);

outcome api_set_abh_blends( ENTITY_LIST const& entities,
    var_radius* left_rad, var_radius* right_rad= NULL,
    var_cross_section* cross_sec= NULL, CURVE* calibration_curve= NULL,
    EDGE* first_edge= NULL, EDGE* last_edge= NULL, ENTITY*
    face_edge1= NULL, ENTITY* face_edge2= NULL, logical smooth1=
    TRUE, logical smooth2= TRUE, double start_setback= 0, double
    end_setback= 0, EDGE* loft_edge= NULL, double start_sbdiff= 0,
    double end_sbdiff= 0, logical start_sbdiff_set= TRUE, logical
    end_sbdiff_set= TRUE, double start_stop_ang = 0, double end_stop_ang =
    0, AcisOptions* ao = NULL);

outcome api_set_acis_options( AcisOptions* ao,
AcisJournal& aj= *(AcisJournal*)NULL_REF, AcisVersion& av
= *(AcisVersion*)NULL_REF);

void api_set_active_part( PART* this_part);

outcome api_set_body_refinement( BODY* body, REFINEMENT*
ref=(REFINEMENT*)NULL, logical apply_to_descendents=
FALSE, AcisOptions* ao = NULL);

outcome api_set_body_vertex_template( BODY* body,
VERTEX_TEMPLATE* tplate, logical apply_to_descendents= FALSE,
AcisOptions* ao = NULL);

outcome api_set_const_chamfers( ENTITY_LIST const& entities,
    double left_range, double right_range, double start_setback= 0,
    double end_setback= 0, double start_setback_diff= 0, double
    end_setback_diff= 0, logical start_setback_diff_set= TRUE, logical
    end_setback_diff_set= TRUE, double start_stop_ang = 0, double end_stop_ang =
    0, AcisOptions* ao= NULL);

outcome api_set_const_rounds( ENTITY_LIST const& entities,
    double radius, double start_setback= 0, double end_setback= 0,
    double start_setback_diff= 0, double end_setback_diff= 0,
    logical start_setback_diff_set= TRUE, logical end_setback_diff_set
    = TRUE, double start_stop_ang = 0, double end_stop_ang = 0,
    blend_how eprop= bl_how_default, AcisOptions* ao= NULL);

outcome api_set_dbl_option(char const* name, double value);

outcome api_set_default_history( HISTORY_STREAM* hs);

outcome api_set_default_refinement( REFINEMENT* ref,
AcisOptions* ao = NULL);

outcome api_set_default_vertex_template( VERTEX_TEMPLATE*
tplate, AcisOptions* ao = NULL);

outcome api_set_ee_cr_blend( BODY* body, ENTITY* ent0,
ENTITY* ent1, bl_convexity cxty, SPAposition const& hlp_pos, double
radius, AcisOptions* ao = NULL);

outcome api_set_ee_vr_blend( BODY* body, ENTITY* ent0,
    ENTITY* ent1, bl_convexity cxty, SPAposition const& hlp_pos, curve
    const& def_curve, var_radius* left_rad, var_radius* right_rad
    = NULL, var_cross_section* vcs= NULL, AcisOptions* ao
    = NULL);

outcome api_set_entity_pattern( ENTITY* in_ent, pattern*
    in_pat, logical copy_pat = TRUE, int seed_index= 0,
    ENTITY_LIST& no_cross_faces=*(ENTITY_LIST*)NULL_REF,
    PAT_CHECK_TYPE check= PAT_DONT_CHECK, AcisOptions* ao = NULL);

outcome api_set_entity_refinement( ENTITY* entity,
REFINEMENT* ref=(REFINEMENT*)NULL, logical apply_to_descendents
= FALSE, AcisOptions* ao = NULL);

outcome api_set_exp_const_chamfer( FACE* bl_face, FACE*
    left_face= NULL, FACE* right_face= NULL, double const&
    left_range=*(double*)NULL_REF, double const& right_range
    =*(double*)NULL_REF, logical const& cvxty=*(logical*)NULL_REF, plane
    const& mid_plane=*(plane*)NULL_REF, AcisOptions* ao
    = NULL);

outcome api_set_exp_const_round( FACE* bl_face, FACE*
    left_face= NULL, FACE* right_face= NULL, double const&
    radius=*(double*)NULL_REF, logical const& cvxty
    =*(logical*)NULL_REF, plane const& mid_plane=*(plane*)NULL_REF,
    logical const& start_cdt=*(logical*)NULL_REF, logical
    const& end_cdt=*(logical*)NULL_REF, AcisOptions* ao
    = NULL);

outcome api_set_exp_co_ro_fbl_att( ENTITY_LIST const&
    start_cross_coedges, ENTITY_LIST const&end_cross_coedges, ENTITY_LIST const&
    spring_coedges, logical const&support_on_left, double const& bl_radius
    =*(double*)NULL_REF, double const& len_tol=*(double*)NULL_REF,
    ENTITY_LIST& bl_faces_noted=*(ENTITY_LIST*)NULL_REF,
    AcisOptions* ao= NULL);

outcome api_set_exp_co_ro_ffbl_att( ENTITY_LIST const&
    start_cross_coedges, ENTITY_LIST const&end_cross_coedges, ENTITY_LIST const&
    left_spring_coedges, ENTITY_LIST const&right_spring_coedges, double const&
    bl_radius=*(double*)NULL_REF, double const& len_tol
    =*(double*)NULL_REF, ENTITY_LIST& bl_faces_noted
    =*(ENTITY_LIST*)NULL_REF, AcisOptions* ao= NULL);

outcome api_set_face_refinement( FACE* face, REFINEMENT*
ref=(REFINEMENT*)NULL, AcisOptions* ao = NULL);

outcome api_set_face_vertex_template( FACE* face,
VERTEX_TEMPLATE* tplate, AcisOptions* ao = NULL);

outcome api_set_file_info(unsigned long, FileInfo const& info
);

outcome api_set_inst_blend( BODY* body, ENTITY* owner,
blend_transition action, SPAposition const& p=*(SPAposition
const*)NULL_REF, AcisOptions* ao = NULL);

outcome api_set_int_option(char const* name, int value);

outcome api_set_journal( AcisOptions* ao, AcisJournal& aj
);

outcome api_set_journal_name( AcisJournal* aj, char* name
);

outcome api_set_lump_refinement( LUMP* lump, REFINEMENT*
ref=(REFINEMENT*)NULL, logical apply_to_descendents=
FALSE, AcisOptions* ao = NULL);

outcome api_set_lump_vertex_template( LUMP* lump,
VERTEX_TEMPLATE* tplate, logical apply_to_descendents= FALSE,
AcisOptions* ao = NULL);

outcome api_set_mesh_manager( MESH_MANAGER* mesh_manager,
AcisOptions* ao = NULL);

outcome api_set_no_merge_attrib( ENTITY_LIST& list,
AcisOptions* ao = NULL);

outcome api_set_options_li( AcisLoftingInterface* obj,
skin_options* opts, AcisOptions* ao = NULL);

outcome api_set_options_si( AcisSkinningInterface* obj,
skin_options* opts, AcisOptions* ao = NULL);

outcome api_set_shell_refinement( SHELL* shell,
REFINEMENT* ref=(REFINEMENT*)NULL, logical apply_to_descendents
= FALSE, AcisOptions* ao = NULL);

outcome api_set_shell_vertex_template( SHELL* shell,
VERTEX_TEMPLATE* tplate, logical apply_to_descendents= FALSE,
AcisOptions* ao = NULL);

outcome api_set_str_option(char const* name, char const*
value);

outcome api_set_tangent_factors_li( AcisLoftingInterface*
obj, double* tan_factors, AcisOptions* opts = NULL);

outcome api_set_var_blends( ENTITY_LIST const& entities,
    double start_radius, double end_radius, double start_setback, double
    end_setback, CURVE* calibration_curve= NULL, EDGE* first_edge
    = NULL, EDGE* last_edge= NULL, doublestart_sbdiff = 0,
    doubleend_sbdiff = 0, logicalstart_sbdiff_set = TRUE, logical
    end_sbdiff_set = TRUE, double start_stop_ang = 0, double end_stop_ang =
    0, AcisOptions* ao= NULL);

outcome api_set_vblend( VERTEX* this_vertex, double bulge,
double setback= 0, bl_continuity bl_contin= slope_continuous,
bl_v_property bl_v_prop= bl_v_unset, AcisOptions* ao= NULL);

outcome api_set_vblend_auto( VERTEX* this_vertex, double
bulge, bl_continuity bl_contin= slope_continuous, bl_v_property
bl_v_prop= bl_v_unset, AcisOptions* ao= NULL);

outcome api_set_vblend_autoblend( VERTEX* this_vertex,
double bulge, bl_continuity bl_contin= slope_continuous,
bl_v_property bl_v_prop= bl_v_unset, AcisOptions* ao= NULL);

outcome api_set_version( AcisOptions* ao, AcisVersion& av
);

outcome api_shadow_taper_faces(int const nface, FACE*
    face[], SPAunit_vector const&draft_dir, double const&
    draft_angle, SPAposition box_low, SPAposition box_high, AcisOptions* ao
    = NULL);

outcome api_sheet_from_ff(int num_faces, FACE*
faces[], BODY*& new_body, AcisOptions* ao = NULL);

outcome api_sheet_thicken( BODY* body, double thickness,
logical both, SPAposition box_low, SPAposition box_high, AcisOptions*
ao = NULL);

outcome api_shell_external( SHELL* given_shell, int&
external, AcisOptions* ao = NULL);

outcome api_show_guides_si( AcisSkinningInterface* obj,
// list of ENTITY_LIST& edgeList, AcisOptions* opts = NULL
);

outcome api_silhouette_edges( FACE* face, const
    SPAtransf& ftrans, const SPAposition& from_point, const SPAposition&
    to_point, int projection_type, ENTITY_LIST* edgelist, AcisOptions*
    ao = NULL);

outcome api_simplify_body( BODY* in_body, AcisOptions* ao
= NULL);

outcome api_simplify_face( FACE* in_face, logical reparam
= FALSE, AcisOptions* ao = NULL);

outcome api_simplify_wires_sli( AcisSLInterface* obj,
AcisOptions* opts = NULL);

outcome api_skin_faces( FACE* face1, FACE* face2,
    BODY*& body, logical arc_length_option = FALSElogical twist_option
    = TRUElogical align_direction_optionlogical simplify_option
    AcisOptions* ao = NULL);

outcome api_skin_wires(int num_wires, BODY* wires[],
BODY*& sheet_body, skin_options* opts, AcisOptions* ao = NULL
);

outcome api_slice( BODY* tool, BODY* blank, SPAunit_vector
const& normal, BODY*& graph, AcisOptions* ao = NULL);

outcome api_slice_complete( BODY* tool, BODY* blank,
SPAunit_vector const& normal, BODY*& graph, AcisOptions* ao =
NULL);

outcome api_slice_of_model(const ENTITY_LIST& model,
ENTITY_LIST& clipped_copy, SPAposition eye, SPAvector targ_eye, double hither,
double yon, logical& MADE_COPY, AcisOptions* ao);

outcome api_smooth_edges_to_curve( ENTITY_LIST const& ents,
CURVE*& calibration_curve, EDGE*& first_edge, EDGE*&
last_edge, AcisOptions* ao= NULL);

outcome api_smooth_edge_seq( EDGE* this_edge,
ENTITY_LIST& edge_list, AcisOptions* ao= NULL);

outcome api_solid_block(const SPAposition& pt1, const
SPAposition& pt2, BODY*& block, AcisOptions* ao = NULL);

outcome api_solid_cylinder_cone(const SPAposition& pt1,
    const SPAposition& pt2, double major_radius, double minor_radius,
    double top_radius, const SPAposition* xpt, BODY*&
    cyl_or_cone, AcisOptions* ao = NULL);

outcome api_solid_sphere(const SPAposition& center, double
radius, BODY*& sph, AcisOptions* ao = NULL);

outcome api_solid_torus(const SPAposition& center, double
major_radius, double minor_radius, BODY*& tor, AcisOptions* ao =
NULL);

outcome api_space_warp( BODY* in_body, law* in_law,
AcisOptions* opts = NULL);

outcome api_spherical_pattern( pattern*& pat, const
SPAposition& center, int num_latitudes, const SPAposition& root, double
spacing= 0.0, AcisOptions* ao = NULL);

outcome api_split_curve( EDGE* crv, const SPAposition*
split_pt, EDGE* split_crv, ENTITY_LIST& new_crvs, AcisOptions*
ao = NULL);

outcome api_split_edges_at_poles( ENTITY* blank,
AcisOptions* ao = NULL);

outcome api_split_edge_at_disc( EDGE* theEdge,
ENTITY_LIST& new_edges, int cont_order= 1, AcisOptions* ao= NULL);

outcome api_split_face( FACE* face, logical split_u, u
parameter curvelogical use_percent, double p, AcisOptions* ao = NULL
);

outcome api_split_face_at_g_disc( FACE* face,
ENTITY_LIST& split_faces, int cont_order= 1, AcisOptions* ao= NULL
);

outcome api_split_periodic_faces( ENTITY* blank,
AcisOptions* ao = NULL);

outcome api_stackmon_limit(size_t limit);

outcome api_start_journal( AcisOptions* ao);

outcome api_start_modeller(int);

outcome api_start_vertex_sli( AcisSLInterface* obj,
WIRE* wire, VERTEX* vertex, AcisOptions* opts = NULL);

outcome api_stitch( BODY* body, ENTITY_LIST&
to_be_stitched, stitch_options* sopts, AcisOptions* aopts= NULL);

outcome api_stop_modeller();

outcome api_stretch_entity( ENTITY* body, SPAposition pos1,
SPAposition pos2, double dis1, double dis2, int continuity, AcisOptions*
opts = NULL);

outcome api_str_to_law(const char* str, law** answer,
law_data** data= NULL, int size= 0, AcisOptions* ao = NULL);

outcome api_subgraph_2dcell(const generic_graph*
whole_graph, generic_graph*&partial_graph, AcisOptions* ao =
NULL);

outcome api_subgraph_3dcell(const generic_graph*
whole_graph, generic_graph*& partial_graph, AcisOptions* ao =
NULL);

outcome api_subset_graph_with_plane(const generic_graph*
    whole_graph, const SPAposition& plane_origin, const SPAunit_vector&
    plane_normal, generic_graph*& partial_graph, AcisOptions* ao =
    NULL);

outcome api_subtract( BODY* tool, BODY* blank,
AcisOptions* ao = NULL);

outcome api_surface_pattern( pattern*& pat, FACE*
    in_face, int num_u, int num_v, const SPAposition& root, logical
    on_boundary= FALSE, const SPAvector& u_dir
    =*(SPAvector*)NULL_REF, const SPAvector& v_dir=*(SPAvector*)NULL_REF,
    AcisOptions* ao = NULL);

outcome api_sweep_more(int nfaces, FACE* faces[],
double dist, SPAposition box_low, SPAposition box_high, AcisOptions*
ao = NULL);

outcome api_sweep_with_options( ENTITY* profile, ENTITY*
path, sweep_options* opts, BODY*& new_body,
AcisOptions* ao = NULL);

outcome api_sw_chain_axis( COEDGE* chain, SPAposition
const& point, SPAunit_vector const& direction, double angle, int
steps, double draft_angle, int draft_type= 2);

outcome api_sw_chain_path( COEDGE* sw_chain, logical,
COEDGE* path, double twist);

outcome api_sw_chain_path_options( COEDGE* sw_chain,
COEDGE* path, sweep_options* swopt, sweeper* broom= NULL);

outcome api_sw_chain_surface( COEDGE* chain, COEDGE*
path, surface const& surf, double draft_angle, int draft_type= 2
);

outcome api_sw_chain_vec( COEDGE* chain, SPAvector const&
sweep_vector, double draft_angle, int draft_type= 2);

outcome api_sw_chain_wire( COEDGE* chain, WIRE* wire,
double draft_angle, int draft_type= 2);

outcome api_sw_face_axis( FACE* face, logical which_side,
SPAposition const& point, SPAunit_vector const& direction, double
angle, int steps, double draft_angle, int draft_type= 2);

outcome api_sw_face_norm( FACE* face, logical which_side,
double distance, double draft_angle, int draft_type= 2);

outcome api_sw_face_surface( FACE* face, logical which_side,
COEDGE* path, surface const& surf, double draft_angle, int draft_type
= 2);

outcome api_sw_face_vec( FACE* face, logical which_side,
SPAvector const& sweep_vector, double draft_angle, int draft_type= 2
);

outcome api_sw_face_wire( FACE* face, logical which_side,
BODY* wire, double draft_angle, int draft_type= 2);

outcome api_sw_wire_axis_sol( BODY* body, SPAposition
const& point, SPAunit_vector const& direction, double angle, int
steps, double draft_angle, int draft_type= 2);

outcome api_taper_faces(int const nface, FACE*
    face[], SPAposition const& point, SPAunit_vector const& normal,
    double const& draft_angle, SPAposition box_low, SPAposition
    box_high, AcisOptions* ao = NULL);

outcome api_terminate_admhoops();

outcome api_terminate_admicon( adm_options* adm_o= NULL,
AcisOptions* acisO= NULL);

outcome api_terminate_advanced_blending();

outcome api_terminate_blending();

outcome api_terminate_booleans();

outcome api_terminate_cellular_topology();

outcome api_terminate_clearance();

outcome api_terminate_constructors();

outcome api_terminate_covering();

outcome api_terminate_deformable_modeling( adm_options*
adm_o= NULL, AcisOptions* acisO= NULL);

outcome api_terminate_euler_ops();

outcome api_terminate_faceter();

outcome api_terminate_face_removal();

outcome api_terminate_generic_attributes();

outcome api_terminate_healing();

outcome api_terminate_hidden_line_removal();

outcome api_terminate_interactive_hidden_line();

outcome api_terminate_intersectors();

outcome api_terminate_kernel();

outcome api_terminate_local_ops();

outcome api_terminate_lopt_ops();

outcome api_terminate_offsetting();

outcome api_terminate_operators();

outcome api_terminate_part_manager();

outcome api_terminate_persistent_id();

outcome api_terminate_precise_hidden_line();

outcome api_terminate_rbi();

outcome api_terminate_rendering();

outcome api_terminate_sbooleans();

outcome api_terminate_shelling();

outcome api_terminate_skinning();

outcome api_terminate_spline();

outcome api_terminate_stitching();

outcome api_terminate_sweeping();

outcome api_terminate_warp();

outcome api_test_deep_copy( ENTITY_LIST const& entity_list,
    double numerical_tolerance= SPAresnor, logical report_all_errors
    = FALSE, char* file1= NULL, char* file2= NULL,
    AcisOptions* ao = NULL);

outcome api_transform_entity( ENTITY* ent, const
SPAtransf& tform, AcisOptions* ao = NULL);

outcome api_trans_edge( EDGE* edgeIn, SPAtransf const& t,
EDGE*& edgeOut, AcisOptions* ao = NULL);

outcome api_trim_2curves(const entity_with_ray& crv1, const
entity_with_ray& crv2, AcisOptions* ao = NULL);

outcome api_trim_chain(int num_crv, const entity_with_ray*
crvs, logical close, ENTITY_LIST& trimmed_crvs, AcisOptions* ao
= NULL);

outcome api_trim_curve(const entity_with_ray& eray1, const
SPAposition* trim_pt, const entity_with_ray* eray2, AcisOptions* ao
= NULL);

outcome api_trim_middle(const entity_with_ray& crv, const
    SPAposition* trim_pt1, const entity_with_ray* trimr1, const
    SPAposition* trim_pt2, const entity_with_ray* trimr2, EDGE*&
    new_edge, AcisOptions* ao = NULL);

outcome api_tweak_extend_faces(int const nface, FACE*
face[], SURFACE* tool_surface[], SPAposition box_low,
SPAposition box_high, AcisOptions* ao = NULL);

outcome api_tweak_faces(int const nface, FACE*
face[], SURFACE* tool_surface[], int reverse[],
SPAposition box_low, SPAposition box_high, AcisOptions* ao = NULL);

outcome api_tweak_faces_init(int const nface, FACE*
    face[], SURFACE* tool_surface[], int reverse[],
    ENTITY_LIST&multiple_sols, SPAposition box_low, SPAposition box_high,
    AcisOptions* ao = NULL);

outcome api_tweak_fix_edge( EDGE* ed, CURVE* cu,
AcisOptions* ao = NULL);

outcome api_tweak_fix_vertex( VERTEX* vt, APOINT* ap,
AcisOptions* ao = NULL);

outcome api_tweak_pick_edge_solution( EDGE* edge, int
soln_no, CURVE* curve = NULL, AcisOptions* ao = NULL);

outcome api_tweak_query_edge_solutions( EDGE* edge,
ENTITY_LIST& curve_list, AcisOptions* ao = NULL);

outcome api_twist_entity( ENTITY* body, SPAposition&
pos1, SPAposition& pos2, double theta1, double theta2, int
continuity, AcisOptions* opts = NULL);

outcome api_uncover_face( FACE* face, AcisOptions* ao
= NULL);

outcome api_unhook_annotations( is_fun is_function=
is_ANNOTATION, BULLETIN_BOARD* bb= NULL, AcisOptions* ao = NULL);

outcome api_unhook_face( FACE* given_face, BODY*&
unhooked_face_body, AcisOptions* ao = NULL);

outcome api_unhook_wire_edge( EDGE* given_edge,
BODY*& unhooked_wire_body, AcisOptions* ao = NULL);

outcome api_unite( BODY* tool, BODY* blank,
AcisOptions* ao = NULL);

outcome api_unite_edges( ENTITY_LIST& eds, BODY*&
outbdy, FILE* fptr, AcisOptions* ao = NULL);

outcome api_unite_wires( BODY* tool, BODY* blank,
AcisOptions* ao = NULL);

outcome api_unstitch_nonmani( BODY* input_body,
BODY*& lumps, BODY*& sheet, BODY*& lamina,
BODY*& wires, AcisOptions* ao = NULL);

outcome api_update_intersection( FACE* tool_face, const
    SPAtransf& ttrans, FACE* blank_face, const SPAtransf& btrans, const
    int number_edges, EDGE* ssi_edges[], logical check_rels
    = TRUE, AcisOptions* ao = NULL);

outcome api_update_tolerance( ENTITY* this_entity,
logical& updated, AcisOptions* ao = NULL);

outcome api_valid_start_vertices_sli( AcisSLInterface* obj,
WIRE* wire, ENTITY_LIST& vertex_list, AcisOptions* opts =
NULL);

outcome api_wcs_create(const SPAposition& origin, const
SPAposition& xpt, const SPAposition& ypt, WCS*& new_wcs,
AcisOptions* ao = NULL);

outcome api_wcs_get_active( WCS*& active_wcs,
AcisOptions* ao = NULL);

outcome api_wcs_set_active( WCS* new_active,
AcisOptions* ao = NULL);

outcome api_wiggle(double width, double depth, double height, int
low_v_type, int high_v_type, int low_u_type, int high_u_type, logical
height_given, BODY*& bodyOut, AcisOptions* ao = NULL);

outcome api_wire_area( BODY* body, double& area,
AcisOptions* ao= NULL);

outcome api_wire_len( BODY* body, double& length,
AcisOptions* ao = NULL);

outcome api_wire_to_chain( BODY* body, ENTITY_LIST& list,
AcisOptions* ao = NULL);

logical are_parallel(const SPAunit_vector& v1, const
SPAunit_vector& v2, logical same_dir= FALSE);

logical are_perpendicular(const SPAunit_vector& v1, const
SPAunit_vector& v2);

logical biparallel( SPAunit_vector const& v1, SPAunit_vector
const& v2, const double res= SPAresnor);

int bs2_curve_accurate_derivs( bs2_curve);

int bs2_curve_add_knot( bs2_curve bs2, double new_knot_param, int
    mult_req, double knot_tol, const SPApar_pos&new_knot_uv
    =*(SPApar_pos*)NULL_REF, const SPApar_vec&new_knot_deriv_below
    =*(SPApar_vec*)NULL_REF, const SPApar_vec& new_knot_deriv_above
    =*(SPApar_vec*)NULL_REF);

SPApar_box bs2_curve_box( bs2_curve cur, double fitol);

logical bs2_curve_closed( bs2_curve cur);

bs2_curve bs2_curve_connect( bs2_curve crv1, bs2_curve crv2);

bs2_curve bs2_curve_construct(int nkts, const SPApar_pos*
pverts, double* knots, int mult);

void bs2_curve_control_points( bs2_curve bs, int&
num_ctrlpts, SPApar_pos*& ctrlpts);

bs2_curve bs2_curve_copy( bs2_curve cur);

void bs2_curve_debug( bs2_curve cur, char const* leader,
FILE* fp= debug_file_ptr);

void bs2_curve_delete( bs2_curve& cur);

SPApar_vec bs2_curve_deriv(double param, bs2_curve cur);

void bs2_curve_eval(double param, bs2_curve cur, SPApar_pos&
x, SPApar_vec& xdot=*(SPApar_vec*)NULL_REF,
SPApar_vec& xdotdot=*(SPApar_vec*)NULL_REF);

int bs2_curve_evaluate(double param, bs2_curve cur,
SPApar_pos& pos, SPApar_vec** deriv= NULL, int nd= 0, int index
= 0);

void bs2_curve_fit(intcurve_data const& int_pts,
bs2_curve& pea_bs);

bs2_curve bs2_curve_for_curve_on_surf( bs3_curve ebs, double
sparam, double eparam, bs3_surface srf, double fit);

bs2_curve bs2_curve_from_ctrlpts(int degree, logical rational,
    logical closed, logical periodic, int num_ctrlpts, const SPAposition*
    ctrlpts[], const double weights[], double, int num_knots, const double
    knots[], double knot_tol);

void bs2_curve_init();

bs2_curve bs2_curve_interp(int npts, SPApar_pos const* pts,
SPApar_vec const& start_dir, SPApar_vec const& end_dir, double fitol
= 0, double& actual_tol=*(double*)NULL_REF);

bs2_curve bs2_curve_join( bs2_curve first_cur, bs2_curve last_cur
);

void bs2_curve_knots( bs2_curve bs, int& num_knots,
double*& knots);

double bs2_curve_knottol();

bs2_curve bs2_curve_make_line( SPApar_pos const& start,
SPApar_pos const& end, double = 0, double& actual_fit
=*(double*)NULL_REF);

bs2_curve bs2_curve_make_rho_conic( SPApar_pos const& start,
    SPApar_pos const& tan_int, SPApar_pos const& end, double rho= 0.5,
    double = 0, double& actual_fit=*(double*)NULL_REF
    );

logical bs2_curve_open( bs2_curve cur);

void bs2_curve_par_trans( bs2_curve bs, SPApar_transf const& t
);

double bs2_curve_period( bs2_curve cur);

logical bs2_curve_periodic( bs2_curve cur);

SPApar_pos bs2_curve_position(double param, bs2_curve cur);

SPAinterval bs2_curve_range( bs2_curve cur);

void bs2_curve_reparam(double start, double end, bs2_curve cur);

bs2_curve bs2_curve_restore();

void bs2_curve_reverse( bs2_curve cur);

logical bs2_curve_same( bs2_curve bs1, bs2_curve bs2, double tol
= 0.0);

void bs2_curve_save( bs2_curve cur);

void bs2_curve_set_closed( bs2_curve crv);

void bs2_curve_set_ctrlpt( bs2_curve curv, int index, SPApar_pos
const& pos, double weight);

void bs2_curve_set_ctrlpts( bs2_curve curv, const SPApar_pos
pos[], const double weight[]);

logical bs2_curve_set_end_prms(double* t0, double* t1,
bs2_curve cur);

void bs2_curve_set_form( bs3_curve_form cv2_form, bs2_curve cv2);

void bs2_curve_set_open( bs2_curve crv);

void bs2_curve_set_periodic( bs2_curve crv);

void bs2_curve_shift(double delta, bs2_curve cur);

bs2_curve bs2_curve_split( bs2_curve& cur, double param,
SPApar_pos const& split_pt=*(SPApar_pos*)NULL_REF,
SPApar_dir const& =*(SPApar_dir*)NULL_REF);

logical bs2_curve_straddles_bs3_surface_knots( bs2_curve
bs2_cur, bs3_surface bs3_sur, logical v_direction);

bs2_curve bs2_curve_subset( bs2_curve old_bs, SPAinterval
const& new_range, double = 0, double& actual_fit
=*(double*)NULL_REF);

SPApar_dir bs2_curve_tangent(double param, bs2_curve cur);

void bs2_curve_to_array( bs2_curve bs, int& dim, int& deg,
int& rat, int& num_ctrlpts, SPAposition*& ctrlpts,
double*& weights, int& num_knots, double*& knots);

bs3_curve bs2_curve_to_bs3_curve( bs2_curve in_cur);

void bs2_curve_trans( bs2_curve, SPAtransf const&);

bs2_curve bs2_curve_u_param_line( bs3_surface surf, double v);

bs2_curve bs2_curve_v_param_line( bs3_surface surf, double u);

void bs2_curve_weights( bs2_curve bs, int& num_weights,
double*& weights);

logical bs2_radius_is_zero( bs2_curve bs2, double tol);

int bs3_curve_accurate_derivs( bs3_curve);

int bs3_curve_add_knot( bs3_curve input, double new_par, int
mult_req, double knot_tol);

void bs3_curve_add_mult_ekn( bs3_curve input);

curve_surf_int* bs3_curve_ana_int( bs3_curve cur, surface
const& sur, double fitol, box const&region_of_interest);

int bs3_curve_arc_3curve( bs3_curve crv1, double& t1,
bs3_curve crv2, double& t2, bs3_curve crv3, double& t3, const
SPAunit_vector& normal, double& radius, SPAposition& center);

int bs3_curve_arc_3curve_modified( bs3_curve crvs[3],
SPAposition pos[3], double ts[3], const SPAunit_vector&
normal, double& radius, SPAposition& center);

SPAbox bs3_curve_box( bs3_curve cur, double fitol);

curve_curve_int* bs3_curve_bs3_curve_int( bs3_curve cur1,
bs3_curve cur2, double tol);

check_status_list* bs3_curve_check( bs3_curve bs3, const
intcurve& ic=*(intcurve*)NULL_REF, const
check_status_list* check= NULL);

void bs3_curve_check_smoothness( bs3_curve bs,
curve_irregularities*& cirr, int& no_pts, int continuity= 1);

logical bs3_curve_closed( bs3_curve cur);

void bs3_curve_compat( bs3_curve b1, bs3_curve b2);

bs_conic_type bs3_curve_conic_type( bs3_curve bs3c);

bs3_curve bs3_curve_connect( bs3_curve bs1, bs3_curve bs2);

bs3_curve bs3_curve_construct(int nkts, const SPAposition*
vertices, double* knots, int mult);

void bs3_curve_control_points( bs3_curve bs, int& num_pts,
SPAposition*& ctrlpts);

curve_surf_int* bs3_curve_con_int( bs3_curve bs, cone
const& con, double fitol, box const&region_of_interest);

bs3_curve bs3_curve_copy( bs3_curve cur);

bs3_curve bs3_curve_cub_fit_to_conic( bs3_curve input, double
fit_tol);

SPAvector bs3_curve_curvature(double param, bs3_curve cur);

void bs3_curve_cylinder( bs3_curve cu, SPAposition& root,
SPAunit_vector& axis, double& rad);

void bs3_curve_debug( bs3_curve cur, char const* leader,
FILE* fp= debug_file_ptr);

int bs3_curve_degree( bs3_curve bs);

void bs3_curve_degree_elevate( bs3_curve& input);

void bs3_curve_delete( bs3_curve& cur);

SPAvector bs3_curve_deriv(double param, bs3_curve cur);

SPAposition bs3_curve_end( bs3_curve bs);

SPAunit_vector bs3_curve_end_tangent( bs3_curve bs);

double bs3_curve_estimate_param(const SPAposition& P,
bs3_curve cu);

void bs3_curve_eval(double param, bs3_curve cur, SPAposition&
x, SPAvector& xdot=*(SPAvector*)NULL_REF,
SPAvector& xdotdot=*(SPAvector*)NULL_REF);

int bs3_curve_evaluate(double param, bs3_curve cur,
SPAposition& pos, SPAvector* const*= NULL, int nd= 0, int index
= 0);

curve_extremum* bs3_curve_extrema( bs3_curve cur,
SPAunit_vector const& dir);

void bs3_curve_facet( bs3_curve bs, double s, double e, double tol,
int nmax, int& npts, SPAposition pts[], double t[]
);

bs3_curve bs3_curve_fillet_curves( bs3_curve crv1, double
radius1, double& t1, bs3_curve crv2, double radius2, double& t2,
const SPAunit_vector&normal);

bs3_curve bs3_curve_from_bs2( bs2_curve curin);

bs3_curve bs3_curve_from_ctrlpts(int degree, logical rational,
    logical closed, logical periodic, int num_ctrlpts, const SPAposition
    ctrlpts[], const double weights[], double ctrlpt_tol, int num_knots,
    const double knots[], double knot_tol, const int& dimension
    =*(int*)NULL_REF);

bs3_curve bs3_curve_hermite_interp(int no_pts, SPAposition*
pts, SPAvector* tans, double* knots);

void bs3_curve_init();

curve_curve_int* bs3_curve_int( bs3_curve& curv1,
bs3_curve& curv2);

double bs3_curve_intcurve_invert(const SPAposition& pos,
const intcurve& this_int, const SPAparameter& param_guess);

bs3_curve bs3_curve_interp(int npts, SPAposition const* pts,
    SPAunit_vector const&start_dir, SPAunit_vector const&end_dir, double
    fitol, double& actual_tol=*(double*)NULL_REF, logical
    periodic = FALSE);

bs3_curve bs3_curve_interp_knots(int npt, SPAposition const*
pos[], double knots[], const SPAvector& sdir, const
SPAvector& edir);

double bs3_curve_invert( SPAposition const& pos, double,
bs3_curve cur, SPAparameter const&param_guess
=*(SPAparameter*)NULL_REF);

bs3_curve bs3_curve_join( bs3_curve first_part, bs3_curve
last_part);

void bs3_curve_knots( bs3_curve bs, int& num_knots,
double*& knots);

double bs3_curve_knottol();

int bs3_curve_knot_mult( bs3_curve input, double knot_value,
double knot_tol);

double bs3_curve_length( bs3_curve cur, SPAinterval const&
cur_range=*(SPAinterval*)NULL_REF, logical approx_OK=
FALSE);

double bs3_curve_length_param( bs3_curve cur, double start, double
length);

logical bs3_curve_line_tan_2crv( bs3_curve crv1, double t1,
bs3_curve crv2, double t2, const SPAunit_vector&normal,
SPAposition& pt1, SPAposition& pt2);

logical bs3_curve_line_tan_pt_crv(const SPAposition& point,
bs3_curve crv, const SPAunit_vector&normal, int nmax, int& num_pts,
SPAposition tanpts[]);

bs3_curve bs3_curve_make_cur( curve const& cur, double
start_param, double end_param, double requested_tol= 0, double&
actual_tol=*(double*)NULL_REF);

bs3_curve bs3_curve_make_ell( ellipse const& ell, double
start_param, double end_param, double = 0, double& actual_tol
=*(double*)NULL_REF);

bs3_curve bs3_curve_make_int( intcurve const& cur, double
start_param, double end_param, double requested_tol= 0, double&
actual_tol=*(double*)NULL_REF);

bs3_curve bs3_curve_make_rho_conic( SPAposition const&
    start, SPAposition const& tan_int, SPAposition const& end, double
    rho= 0.5, double = 0, double& actual_tol
    =*(double*)NULL_REF);

bs3_curve bs3_curve_make_str( straight const& str, double
start_param, double end_param, double = 0, double& actual_tol
=*(double*)NULL_REF);

double bs3_curve_max_dist_to_point_bound( bs3_curve bs3_curve,
const SPAposition& P);

void bs3_curve_mergeable( bs3_curve b1, bs3_curve b2);

SPAposition bs3_curve_mid( bs3_curve bs);

SPAunit_vector bs3_curve_mid_tangent( bs3_curve bs);

logical bs3_curve_modify( bs3_curve bs_cur, SPAposition
const& pos, SPAunit_vector const& dir, double t);

logical bs3_curve_mult( bs3_curve input);

SPAvector bs3_curve_nderiv(double param, bs3_curve cur, int nder);

int bs3_curve_nspans( bs3_curve cur);

int bs3_curve_num_ctlpts( bs3_curve bs);

bs3_curve bs3_curve_offset_by_dist(const bs3_curve bs, double
dist, logical to_right, const SPAunit_vector&plane_nor
=*(SPAunit_vector*)NULL_REF);

bs3_curve bs3_curve_offset_by_vec(const bs3_curve bs, const
SPAvector& offset);

logical bs3_curve_open( bs3_curve cur);

double bs3_curve_param_length( bs3_curve cur, double start, double
end);

double bs3_curve_period( bs3_curve cur);

logical bs3_curve_periodic( bs3_curve cur);

void bs3_curve_perp( SPAposition const& pos, bs3_curve cur,
    SPAposition& foot, SPAunit_vector& tan, SPAparameter const&
    param_guess=*(SPAparameter*)NULL_REF, SPAparameter&
    param_actual=*(SPAparameter*)NULL_REF, double
    quick_exit_dist_tol= 0.0);

int bs3_curve_planar(const bs3_curve& bc,
SPAunit_vector& normal, double tolerance= SPAresabs);

curve_surf_int* bs3_curve_pla_int( bs3_curve bs, plane
const& pla, double fitol, box const&region_of_interest);

SPAposition bs3_curve_position(double param, bs3_curve cur);

bs3_curve bs3_curve_project( bs3_curve in_cur, const curve*
path_c, const plane& to_surf);

bs3_curve bs3_curve_rail_from_cen( bs3_curve input,
SPAunit_vector up_dir, double twist_ang);

SPAinterval bs3_curve_range( bs3_curve cur);

logical bs3_curve_rational( bs3_curve input);

void bs3_curve_rem_extra_knots( bs3_curve bs3, double tol);

void bs3_curve_reparam(double start, double end, bs3_curve cur);

bs3_curve bs3_curve_restore();

void bs3_curve_reverse( bs3_curve cur);

logical bs3_curve_same( bs3_curve bs1, bs3_curve bs2, double tol
= 0.0);

void bs3_curve_save( bs3_curve cur);

curve_curve_int* bs3_curve_self_int( bs3_curve& curv);

void bs3_curve_set_closed( bs3_curve crv);

void bs3_curve_set_ctrlpt( bs3_curve curv, int index, double*
pos, double weight);

void bs3_curve_set_ctrlpts( bs3_curve curv, int cpt_count,
double* pos, double* weight);

double bs3_curve_set_fitol(int npoints, SPAposition const*
pos, double opt_tol= -1.0);

void bs3_curve_set_form( bs3_curve bs3);

void bs3_curve_set_open( bs3_curve crv);

void bs3_curve_set_periodic( bs3_curve crv);

void bs3_curve_shift(double delta, bs3_curve cur);

bs3_curve bs3_curve_span(int n, bs3_curve cur);

rat_poly_vec bs3_curve_span_poly(int n, bs3_curve cur);

SPAinterval bs3_curve_span_range(int n, bs3_curve cur);

curve_surf_int* bs3_curve_sph_int( bs3_curve bs, sphere
const& sph, double fitol, box const&region_of_interest);

bs3_curve bs3_curve_split( bs3_curve& cur, double param,
    SPAposition const& split_pt=*(SPAposition*)NULL_REF,
    SPAunit_vector const&split_dir=*(SPAunit_vector*)NULL_REF,
    SPAunit_vector const&high_split_dir
    =*(SPAunit_vector*)NULL_REF);

curve_surf_int* bs3_curve_spl_int( bs3_curve bs_cur, spline
const& spl, double fitol, box const& b);

SPAposition bs3_curve_start( bs3_curve bs);

SPAunit_vector bs3_curve_start_tangent( bs3_curve bs);

bs3_curve bs3_curve_subset( bs3_curve old_bs, SPAinterval
const& new_range, double = 0, double& actual_fit
=*(double*)NULL_REF);

SPAunit_vector bs3_curve_tangent(double param, bs3_curve cur);

bs3_curve_tancone bs3_curve_tangent_cone( bs3_curve cur, logical
approx_OK= FALSE);

logical bs3_curve_tan_pt_crv(const SPAposition& point,
    bs3_curve crv, const SPAunit_vector& normal, double* t, logical
    old_method= FALSE, const SPAvector& xa
    =(*(SPAvector*)NULL_REF), const SPAvector& ya=(*(SPAvector*)NULL_REF),
    const SPAposition& guess_pt
    =(*(SPAposition*)NULL_REF);

void bs3_curve_term();

logical bs3_curve_testpt( SPAposition const& pos, double tol,
    bs3_curve cur, SPAparameter const&param_guess
    =*(SPAparameter*)NULL_REF, SPAparameter& param_actual
    =*(SPAparameter*)NULL_REF);

curve_surf_int* bs3_curve_tor_int( bs3_curve bs, torus
const& tor, double fitol, box const&region_of_interest);

void bs3_curve_to_array( bs3_curve bs, int& dim, int& deg,
logical& rat, int& num_ctrlpts, SPAposition*& ctrlpts,
double*& weights, int& num_knots, double*& knots);

bs2_curve bs3_curve_to_bs2_curve( bs3_curve in_cur);

void bs3_curve_trans( bs3_curve cur, SPAtransf const& t);

bs3_curve bs3_curve_u_param_line( bs3_surface surf, double v);

bs3_curve bs3_curve_v_param_line( bs3_surface surf, double u);

logical bs3_curve_weight( bs3_curve bs, int index, double&
weight);

void bs3_curve_weights( bs3_curve bs, int& num_pts,
double*& weights);

bs3_surface bs3_surface_3crv(const bs3_curve& base, const
bs3_curve& right, const bs3_curve& left);

bs3_surface bs3_surface_4crv(const bs3_curve& bottom, const
bs3_curve& right, const bs3_curve& top, const bs3_curve& left);

int bs3_surface_accurate_derivs( bs3_surface);

int bs3_surface_add_knot(double par, int multp, bs3_surface
in_sur, int u_or_v, double knot_tol);

bs3_surface bs3_surface_bicubic(int num_upts, int num_vpts,
    double u_params[], double v_params[], SPAposition
    points[], SPAvector u_tans[], SPAvector v_tans[],
    SPAvector twists[]);

bs3_surface bs3_surface_bispan(int i, udirectionint j, vdirection
bs3_surface sur);

rat_bipoly_vec bs3_surface_bispan_poly(int nuspan, int nvspan,
bs3_surface sur);

SPApar_box bs3_surface_bispan_range(int i, int j, bs3_surface sur
);

void bs3_surface_boundary_angle( bs3_surface sur, double&
u_angle, double& v_angle);

SPAbox bs3_surface_box( bs3_surface bs, SPApar_box const&
=*(SPApar_box*)NULL_REF);

check_status_list* bs3_surface_check( bs3_surface bs3, const
    spline& spl=*(spline*)NULL_REF, const check_fix& fix
    =*(check_fix*)NULL_REF, check_fix& fixed=*(check_fix*)NULL_REF, const
    check_status_list*check= NULL);

logical bs3_surface_closed_u( bs3_surface bs);

logical bs3_surface_closed_v( bs3_surface bs);

void bs3_surface_control_points( bs3_surface bs, int& num_u,
int& num_v, SPAposition*& ctrlpts);

bs3_surface bs3_surface_copy( bs3_surface bs);

double bs3_surface_cross( SPApar_pos const& uv,
SPAunit_vector const& dir, bs3_surface bs);

void bs3_surface_debug( bs3_surface sur, char const* leader,
FILE* fp= debug_file_ptr);

int bs3_surface_degree_u( bs3_surface bs);

int bs3_surface_degree_v( bs3_surface bs);

void bs3_surface_delete( bs3_surface& bs);

int bs3_surface_dim( bs3_surface bs);

SPApar_pos bs3_surface_estimate_param( SPAposition const&
pos, bs3_surface surface, logical recurse= FALSE);

void bs3_surface_eval( SPApar_pos const& uv, bs3_surface bs,
SPAposition& pos, SPAvector* d1= NULL, SPAvector* d2= NULL);

int bs3_surface_evaluate( SPApar_pos const& uv, bs3_surface
sur, SPAposition& pos, SPAvector** deriv= NULL, int
nderiv= 0, int uindex= 0, int vindex= 0);

bs3_surface bs3_surface_fit(double fittol, int num_u, int num_v,
const SPAposition pts[], const SPAunit_vectordu_s[],
const SPAunit_vector du_e[]);

double bs3_surface_fitol( bs3_surface sur);

bs3_surface bs3_surface_from_ctrlpts(int degree_u, logical
    rational_u, int form_u, int& pole_u, int num_ctrlpts_u, int degree_v,
    logical rational_v, int form_v, int& pole_v, int num_ctrlpts_v, const
    SPApositionctrlpts[], const double weights[], double, int
    num_knots_u, const double knots_u[], int num_knots_v, const double
    knots_v[], double knot_tol);

bs3_surface bs3_surface_hermite(const SPAposition* corners,
const SPAvector* uderivs, const SPAvector* vderivs, const
SPAvector* twists);

bs3_surface bs3_surface_hermite_intp(int nu, int nv,
SPAposition* pts, SPAvector* u_partials, SPAvector* v_partials,
SPAvector* uv_partials, double* u_knots, double* v_knots);

int bs3_surface_hull_planes( bs3_surface surface_,
SPAposition* points, SPAunit_vector* normals);

void bs3_surface_ij_ctrlpt( bs3_surface in_sur, int i, int j,
SPAposition& ctrl_pos, double& weight, logical& is_rational, int&
dimension);

double bs3_surface_ij_knu( bs3_surface bs, int i, int j);

double bs3_surface_ij_knv( bs3_surface bs, int i, int j);

void bs3_surface_init();

bs3_surface bs3_surface_interp_knots(int nu, int nv,
SPAposition* points, double knotsu[], double knotsv[],
SPAvector* deru, SPAvector* derv, SPAvector deruv[]);

bs3_surface bs3_surface_intp(int num_u, int num_v, const
    SPAposition pts[], const SPAunit_vectordu_s[], const
    SPAunit_vectordu_e[], const SPAunit_vectordv_s[], const
    SPAunit_vectordv_e[]);

SPApar_dir bs3_surface_invdir( SPAunit_vector const& dir,
SPApar_pos const& uv, bs3_surface bs);

SPApar_pos bs3_surface_invert( SPAposition const& pos,
bs3_surface bs, SPApar_pos const& uv=*(SPApar_pos*)NULL_REF
);

bs3_surface bs3_surface_join_u( bs3_surface first_part,
bs3_surface last_part);

bs3_surface bs3_surface_join_v( bs3_surface first_part,
bs3_surface last_part);

void bs3_surface_knots_u( bs3_surface bs, int& num_knots_u,
double*& uknots);

void bs3_surface_knots_v( bs3_surface bs, int& num_knots_v,
double*& vknots);

double bs3_surface_knottol();

bs3_surface bs3_surface_loft_curves( bs3_curve*
curves[], double knots[], double fitol, int n, double& actual_tol
);

bs3_surface bs3_surface_loft_u_curves(int n_crvs, bs3_curve
crvs[], double knots[]);

bs3_surface bs3_surface_make_con( cone const& con, SPAbox
const& region_of_interest, double = 0, double& actual_fit
=*(double*)NULL_REF, SPApar_transf& pt=*(SPApar_transf*)NULL_REF);

bs3_surface bs3_surface_make_pipe(double radius, curve
    const& spine, curve const& zero, SPAinterval const& u_range,
    double requested_fit= 0, double& actual_fit
    =*(double*)NULL_REF);

bs3_surface bs3_surface_make_pipe_boundary(double radius, curve
    const& spine, curve const& lowu, curve const& highu, double
    requested_fit, double& actual_fit=*(double*)NULL_REF,
    bs2_curve& lowp=*(bs2_curve*)NULL_REF, bs2_curve& highp
    =*(bs2_curve*)NULL_REF);

bs3_surface bs3_surface_make_pla( plane const& pla, SPAbox
const& region_of_interest, double = 0, double& actual_fit
=*(double*)NULL_REF, SPApar_transf& pt=*(SPApar_transf*)NULL_REF);

bs3_surface bs3_surface_make_sph( sphere const& sph, SPAbox
const& region_of_interest, double = 0, double& actual_fit
=*(double*)NULL_REF, SPApar_transf& pt=*(SPApar_transf*)NULL_REF);

bs3_surface bs3_surface_make_spl( spline const& spl, SPAbox
const&, double = 0, double& actual_fit
=*(double*)NULL_REF, SPApar_transf&=*(SPApar_transf*)NULL_REF);

bs3_surface bs3_surface_make_sur( surface const& sur, SPAbox
    const& region_of_interest, double requested_fit= 0, double&
    actual_fit=*(double*)NULL_REF, SPApar_transf& pt
    =*(SPApar_transf*)NULL_REF);

bs3_surface bs3_surface_make_tor( torus const& tor, SPAbox
const& region_of_interest, double = 0, double& actual_fit
=*(double*)NULL_REF, SPApar_transf& pt=*(SPApar_transf*)NULL_REF);

double bs3_surface_max_size_to_param_line( bs3_surface
bs3_surf, const SPAposition& P, double param_val, logical from_hi_edge,
logical v_param_line);

int bs3_surface_mult_eku( bs3_surface in_sur);

int bs3_surface_mult_ekv( bs3_surface in_sur);

int bs3_surface_ncu( bs3_surface bs);

int bs3_surface_ncv( bs3_surface bs);

int bs3_surface_nku( bs3_surface bs);

int bs3_surface_nkv( bs3_surface bs);

SPAunit_vector bs3_surface_normal( SPApar_pos const& uv,
bs3_surface bs);

int bs3_surface_nspans_u( bs3_surface sur);

int bs3_surface_nspans_v( bs3_surface sur);

bs3_surface bs3_surface_offset(const bs3_surface orig_surf,
double offset_dist, double offset_tol);

logical bs3_surface_periodic_u( bs3_surface bs);

logical bs3_surface_periodic_v( bs3_surface bs);

double bs3_surface_period_u( bs3_surface bs);

double bs3_surface_period_v( bs3_surface bs);

void bs3_surface_perp( SPAposition const& point, bs3_surface
    bs, SPAposition& foot, SPAunit_vector& norm, SPApar_pos
    const& uv_guess=*(SPApar_pos*)NULL_REF, SPApar_pos&
    uv_actual=*(SPApar_pos*)NULL_REF);

logical bs3_surface_planar( bs3_surface bs, SPAunit_vector&
pln_norm);

int bs3_surface_poles_u( bs3_surface bs);

int bs3_surface_poles_v( bs3_surface bs);

SPAposition bs3_surface_position( SPApar_pos const& uv,
bs3_surface bs);

void bs3_surface_prin_curv( SPApar_pos const& uv, bs3_surface
bs, SPAunit_vector& u1, double& c1, SPAunit_vector& u2,
double& c2);

bs3_surface bs3_surface_proc( SPAinterval& u_interval,
SPAinterval& v_interval, pt_eval_fn_t pt_fn, vec_eval_fn_t du_fn,
vec_eval_fn_t dv_fn, vec_eval_fn_t duv_fn, void* data, double res);

SPApar_box bs3_surface_range( bs3_surface bs);

SPAinterval bs3_surface_range_u( bs3_surface bs);

SPAinterval bs3_surface_range_v( bs3_surface bs);

logical bs3_surface_rational_u( bs3_surface bs);

logical bs3_surface_rational_v( bs3_surface bs);

void bs3_surface_remove_extra_knots( bs3_surface bs, double
knot_tol);

void bs3_surface_reparam_u(double start, double end, bs3_surface
bs);

void bs3_surface_reparam_v(double start, double end, bs3_surface
bs);

bs3_surface bs3_surface_restore();

bs3_surface bs3_surface_revolve_curve( bs3_curve gen, straight
const& axis, double start_ang= 0.0, double stop_ang= 0.0, double
= 0, double& actual_fit=*(double*)NULL_REF);

bs3_surface bs3_surface_ruled(const bs3_curve& crv1, const
bs3_curve& crv2);

bs3_surface bs3_surface_rule_from_pt(const SPAposition& p,
const bs3_curve crv);

logical bs3_surface_same( bs3_surface bs1, bs3_surface bs2, double
tol= 0.0);

void bs3_surface_save( bs3_surface sur);

void bs3_surface_set_closed_u( bs3_surface surf);

void bs3_surface_set_closed_v( bs3_surface surf);

void bs3_surface_set_ctrlpt( bs3_surface surf, int uindex, int
vindex, double* pos, double weight);

void bs3_surface_set_ctrlpts( bs3_surface surf, int u_cpt_count,
int v_cpt_count, double* pos_vec, double* weight);

void bs3_surface_set_form( bs3_surface);

void bs3_surface_set_open_u( bs3_surface surf);

void bs3_surface_set_open_v( bs3_surface surf);

void bs3_surface_set_periodic_u( bs3_surface surf);

void bs3_surface_set_periodic_v( bs3_surface surf);

void bs3_surface_shift_u(double delta, bs3_surface bs);

void bs3_surface_shift_v(double delta, bs3_surface bs);

surf_surf_int* bs3_surface_sil( bs3_surface, logical,
view_spec const&, SPAbox const&);

logical bs3_surface_singular_u(double u, bs3_surface bs);

logical bs3_surface_singular_v(double v, bs3_surface bs);

bs3_surface bs3_surface_skin_curves( ENTITY_LIST& curves);

SPAinterval bs3_surface_span_range_u(int i, bs3_surface sur);

SPAinterval bs3_surface_span_range_v(int j, bs3_surface sur);

bs3_surface bs3_surface_split_u( bs3_surface& sur, double
uparam);

bs3_surface bs3_surface_split_v( bs3_surface& sur, double
vparam);

bs3_surface bs3_surface_subset( bs3_surface old_bs, SPApar_box
const&new_range, double = 0, double& actual_fit
=*(double*)NULL_REF);

bs3_surface bs3_surface_sum_curves( bs3_curve u_bs, u direction
bs3_curve v_bs, v directiondouble = 0, double& actual_fit
=*(double*)NULL_REF);

bs3_curve bs3_surface_sum_x_pla_str(const bs3_surface in_sur,
const SPAposition&, const SPAunit_vector& path_dir, const
SPAposition& plane_root, const SPAunit_vector& plane_nor );

logical bs3_surface_testpt( SPAposition const& pos, double
    tol, bs3_surface bs, SPApar_pos const& uv_guess
    =*(SPApar_pos*)NULL_REF, SPApar_pos& uv_actual=*(SPApar_pos*)NULL_REF
    );

void bs3_surface_to_array( bs3_surface srf, int& dim,
    logical& rational_u, logical& rational_v, int& form_u, int&
    form_v, int& pole_u, int& pole_v, int& num_u, int& num_v,
    SPAposition*& ctrlpts, double*& weights, int& degree_u, int&
    num_uknots, double*& uknots, int& degree_v, int& num_vknots,
    double*& vknots);

void bs3_surface_trans( bs3_surface sur, SPAtransf const& t);

SPApar_vec bs3_surface_unitvec( SPAunit_vector const& dir,
SPApar_pos const& uv, bs3_surface bs);

void bs3_surface_weights( bs3_surface bs, int& num_u, int&
num_v, double*& weights);

bs3_surface bs3_surface_wiggle(double width, double depth, double
height, int low_v_type= 1, int high_v_type= -2, int low_u_type=
2, int high_u_type= -1);

void check_outcome(const outcome& result);

void clear_debug_lists();

logical closest_points(const SPAposition& p1, const
SPAunit_vector& v1, const SPAposition& p2, const SPAunit_vector& v2,
double& t1, SPAposition& pt1, double& t2, SPAposition& pt2);

void collapse_all_free_lists();

void compute_axes_from_z(const SPAunit_vector& z_axis,
SPAunit_vector& x_axis, SPAunit_vector& y_axis);

SPAtransf coordinate_transf( SPAposition const& new_origin,
SPAunit_vector const& new_x_axis, SPAunit_vector const& new_y_axis);

int count_parts();

BULLETIN_BOARD* current_bb();

surf_surf_int* d3_sf_sf_int(const surface& sf0, const
    surface& sf1, const box& b_in, double fitol= resfit, const
    help_point* help_pts= 0, COMPLETENESS_TYPEcompleteness= ALL_CURVES,
    logical safe_area= FALSE, const double off0= 0.0, const double off1
    = 0.0, logical abort_on_illegal_surf = FALSE);

void debug_int(char const* title, int val, FILE* fp);

char const* debug_leader();

void debug_new_pointer( ENTITY const* ptr, FILE* fp);

void debug_real(char const* title, double val, FILE* fp);

void debug_string(char const* title, char const* str,
FILE* fp);

logical delete_all_delta_states( HISTORY_STREAM*&
del_stream, logical keep_stream = FALSE);

void delete_GC_Objects();

void delete_hit_list( hit* list);

double distance_to_line(const SPAposition& pt, const
SPAposition& line_pt, const SPAunit_vector& line_dir);

double distance_to_plane(const SPAposition& pt, const
SPAposition& plane_pt, const SPAunit_vector& normal);

double distance_to_point(const SPAposition& pt1, const
SPAposition& pt2);

logical dist_pt_to_line( SPAposition const& pt, SPAposition
const& line_pt, SPAvector const& line_vec, double& dist,
double& line_prm);

int DM_add_area_cstrn(int& rtn_err, DS_dmod* dmod, int
tag_flag, int zone_flag, DS_zone* zone, void* src_data= NULL, int
tag= -1, SDM_options* sdmo= NULL);

int DM_add_attractor(int& rtn_err, DS_dmod* dmod, int
tag_flag, double* image_pt= NULL, int power= 2, double gain=
0.0, int tag= -1, SDM_options* sdmo= NULL);

int DM_add_crv_cstrn(int& rtn_err, DS_dmod* dmod, int
    tag_flag, DS_dmod* parent_dmod= NULL, int domain_flag= 0,
    DS_pfunc* src_C_pfunc= NULL, DS_pfunc* src_W_pfunc= NULL,
    DS_pfunc* src_Wn_pfunc= NULL, DS_pfunc* src_Wnn_pfunc= NULL,
    void(* src_CW_func)(void* src_data, double s, double* C,
    double* Cs, double* W, double* Wu, double* Wv, double* Wuu,
    double* Wuv, double* Wvv, double& dist2)= NULL, void*
    src_data= NULL, DS_CSTRN_SRC src_type= ds_user_cstrn, int behavior
    =(1 << 3), double tang_gain= 1.0, int tag= -1,
    SDM_options* sdmo= NULL);

int DM_add_crv_load(int& rtn_err, DS_dmod* dmod, int
    tag_flag, int domain_flag, DS_pfunc* src_C_pfunc, DS_pfunc*
    src_W_pfunc= NULL, double gain= 0.0, int tag= -1, SDM_options*
    sdmo= NULL);

int DM_add_curve_patch(int& rtn_err, DS_dmod* dmod, int
domain_flag, double min, double max, int refinement, void* patch_entity,
void* seam_data[2], SDM_options* sdmo= NULL);

int DM_add_dist_press(int& rtn_err, DS_dmod* dmod, int
    tag_flag= 1, int domain_flag= 1, double* domain_min= NULL,
    double* domain_max= NULL, double gain= 0.0, int negate_flag= 0,
    int tag= -1, SDM_options* sdmo= NULL);

int DM_add_link_C0_load(int& rtn_err, int& tag_shift,
    DS_dmod* dmod1, DS_dmod* dmod2, int domain_flag, DS_pfunc*
    src1_C_pfunc, DS_pfunc* src2_C_pfunc, DS_pfunc* src1_W_pfunc=
    NULL, DS_pfunc* src1_Wn_pfunc= NULL, DS_pfunc*
    src1_Wnn_pfunc= NULL, DS_pfunc* src2_W_pfunc= NULL, DS_pfunc*
    src2_Wn_pfunc= NULL, DS_pfunc* src2_Wnn_pfunc= NULL, void*
    src1_data= NULL, void* src2_data= NULL, void(* src_CW_func)
    (void* src_data, double s, double* C, double* Cs, double* W,
    double* Wu, double* Wv, double* Wuu, double* Wuv, double*
    Wvv, double& dist2)= NULL, double gain= 10000000., int tag
    = -1, DM_flipped_stateflipped_state= DM_flip_unknown,
    SDM_options* sdmo= NULL);

int DM_add_link_C1_load(int& rtn_err, int& tag_shift,
    DS_dmod* dmod1, DS_dmod* dmod2, int domain_flag, DS_pfunc*
    src1_C_pfunc, DS_pfunc* src2_C_pfunc, DS_pfunc* src1_W_pfunc=
    NULL, DS_pfunc* src1_Wn_pfunc= NULL, DS_pfunc*
    src1_Wnn_pfunc= NULL, DS_pfunc* src2_W_pfunc= NULL, DS_pfunc*
    src2_Wn_pfunc= NULL, DS_pfunc* src2_Wnn_pfunc= NULL, void*
    src1_data= NULL, void* src2_data= NULL, void(* src_CW_func)
    (void* src_data, double s, double* C, double* Cs, double* W,
    double* Wu, double* Wv, double* Wuu, double* Wuv, double*
    Wvv, double& dist2)= NULL, double gain= 10000000., int tag
    = -1, DM_flipped_stateflipped_state= DM_flip_unknown,
    SDM_options* sdmo= NULL);

int DM_add_link_cstrn(int& rtn_err, int& tag_shift,
    DS_dmod* dmod1, DS_dmod* dmod2, int domain_flag, DS_pfunc*
    src1_C_pfunc, DS_pfunc* src2_C_pfunc, DS_pfunc* src1_W_pfunc=
    NULL, DS_pfunc* src1_Wn_pfunc= NULL, DS_pfunc*
    src1_Wnn_pfunc= NULL, DS_pfunc* src2_W_pfunc= NULL, DS_pfunc*
    src2_Wn_pfunc= NULL, DS_pfunc* src2_Wnn_pfunc= NULL, void*
    src1_data= NULL, void* src2_data= NULL, void(* src_CW_func)
    (void* src_data, double s, double* C, double* Cs, double* W,
    double* Wu, double* Wv, double* Wuu, double* Wuv, double*
    Wvv, double& dist2)= NULL, int behavior=(1 <<
    4)|(0)|(1 << 10)|(0), double tang_gain= 1.0, int tag=
    -1, SDM_options* sdmo= NULL);

int DM_add_pt_cstrn(int& rtn_err, DS_dmod* dmod, int
    tag_flag, DS_dmod* parent_dmod, int domain_flag, double* dpt,
    void* src_data= NULL, cstrn object DS_CSTRN_SRC src_type=
    ds_user_cstrn, int behavior=(1 << 3), double* ipt= NULL,
    double* domain1_dir= NULL, double* domain2_dir= NULL,
    double* tang1_val= NULL, double* tang2_val= NULL, double*
    norm_val= NULL, double* binorm_val= NULL, double*
    curv1_val= NULL, double* curv2_val= NULL, int tag= -1,
    SDM_options* sdmo= NULL);

int DM_add_pt_press(int& rtn_err, DS_dmod* dmod, int
tag_flag, int domain_flag, double* dpt, double gain= 0.0, int
negate_flag= 0, int tag= -1, SDM_options* sdmo= NULL);

int DM_add_spring(int& rtn_err, DS_dmod* dmod, int
    tag_flag, int domain_flag, double* dpt, double* ipt= NULL, int
    ipt_flag= 0, double gain= 0.0, int tag= -1, SDM_options* sdmo
    = NULL);

int DM_add_spring_set(int& rtn_err, DS_dmod* dmod, int
    tag_flag, int domain_flag, int pt_count, double* domain_pts, double*
    free_pts= NULL, double gain= 0.0, int tag= -1, SDM_options*
    sdmo= NULL);

int DM_add_surface_patch(int& rtn_err, DS_dmod* dmod, int
    domain_flag, double pt1[2], double pt2[2], int refinement,
    void* patch_entity, int seam_count, DS_pfunc** seam,
    void** seam_data, SDM_options* sdmo= NULL);

int DM_add_vector_load(int& rtn_err, DS_dmod* dmod, int
tag_flag, double* image_vec= NULL, double gain= 0.0, int tag=
-1, SDM_options* sdmo= NULL);

int DM_assign_next_tag(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

void DM_build_ellipse_seam(int& rtn_err, DS_dmod* dmod,
    int domain_flag, double cpt[2], double axis1[2],
    double axis2[2], double min[2], double max[2],
    int& pfunc_count, DS_pfunc**& pfunc, SDM_options*
    sdmo= NULL);

void DM_build_fillet_square_seam(int& rtn_err, DS_dmod*
    dmod, int domain_flag, double min[2], double max[2],
    double radius, int& pfunc_count, DS_pfunc**& pfunc,
    SDM_options* sdmo= NULL);

void DM_build_square_seam(int& rtn_err, DS_dmod* dmod,
    int domain_flag, double min[2], double max[2],
    int& pfunc_count, DS_pfunc**& pfunc, SDM_options*
    sdmo= NULL);

DS_zone* DM_build_square_zone(int& rtn_err,
DS_dmod* dmod, int domain_flag, double min[2], double
max[2], SDM_options* sdmo= NULL);

DS_TAGS DM_classify_tag(int& rtn_err, DS_dmod* dmod, int
tag, SDM_options* sdmo= NULL);

int DM_convert_loads_and_cstrns(int& rtn_err, DS_dmod*
dmod, int tag, DM_target_memory flag= DM_remember_target,
SDM_options* sdmo= NULL);

DS_dmod* DM_copy_dmod(int& rtn_err, DS_dmod* dmod,
int walk_flag= 0, SDM_options* sdmo= NULL);

DS_pfunc* DM_copy_pfunc(int& rtn_err, DS_pfunc*
pfunc, SDM_options* sdmo= NULL);

void DM_delete_dmod(int& rtn_err, DS_dmod*& dmod,
SDM_options* sdmo= NULL);

void DM_delete_pfunc(int& rtn_err, DS_pfunc*& pfunc,
SDM_options* sdmo= NULL);

void DM_delete_zone(int& rtn_err, DS_zone*& zone,
SDM_options* sdmo= NULL);

void DM_draw_icon(int& rtn_err, const DM_icon_draw_args&
args, DS_dmod* dmod, const int* tags, int ntags, SDM_options*
sdmo= NULL);

void DM_elevate_dmod_degree(int& rtn_err, DS_dmod* dmod,
int cont_flag, SDM_options* sdmo= NULL);

void DM_eval_crv_src_domain(int& rtn_err, DS_dmod* dmod,
int tag, const double* s, int npts, DM_dbl_array& C,
SDM_options* sdmo= NULL);

void DM_eval_crv_tgt(int& rtn_err, DS_dmod* dmod, int tag,
const double* s, int npts, DM_dbl_array& W, SDM_options* sdmo
= NULL);

void DM_eval_dmod(int& rtn_err, DS_dmod* dmod, int
    domain_flag, double* dpt, double* W, double* dWu= NULL,
    double* dWv= NULL, double* dWuu= NULL, double* dWuv=
    NULL, double* dWvv= NULL, double* dWuuu= NULL,
    double* dWuuv= NULL, double* dWuvv= NULL, double* dWvvv
    = NULL, SDM_options* sdmo= NULL);

void DM_eval_pfunc(int& rtn_err, DS_pfunc* pfunc, int
    domain_flag, double* dpt, double* W, double* dWu= NULL,
    double* dWv= NULL, double* dWuu= NULL, double* dWuv=
    NULL, double* dWvv= NULL, double* dWuuu= NULL,
    double* dWuuv= NULL, double* dWuvv= NULL, double* dWvvv
    = NULL, SDM_options* sdmo= NULL);

void DM_extrapolate_dmod(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

DS_cstrn* DM_find_cstrn_by_tag(int& rtn_err,
DS_dmod* dmod, int tag, int& patch_tag1, int& patch_tag2,
SDM_options* sdmo= NULL);

DS_load* DM_find_load_by_tag(int& rtn_err, DS_dmod*
dmod, int tag, int& patch_tag, SDM_options* sdmo= NULL);

DS_dmod* DM_find_patch_by_entity(int& rtn_err,
DS_dmod* dmod, void* entity, SDM_options* sdmo= NULL);

DS_dmod* DM_find_patch_by_tag(int& rtn_err,
DS_dmod* dmod, int tag, SDM_options* sdmo= NULL);

DS_dmod* DM_find_patch_by_tag_flag(int& rtn_err,
DS_dmod* dmod, int tag_flag, int& walk_flag, SDM_options* sdmo=
NULL);

int DM_find_tag_by_image_line(int& rtn_err, DS_dmod*
dmod, double* p0, double* p1, double max_dist, int& pt_index,
SDM_options* sdmo= NULL);

DS_dmod* DM_get_active_patch(int& rtn_err, DS_dmod*
dmod, SDM_options* sdmo= NULL);

int DM_get_active_patch_tag(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

void DM_get_alpha(int& rtn_err, DS_dmod* dmod,
double* alpha, SDM_options* sdmo= NULL);

int DM_get_area_cstrn_flag(int& rtn_err, DS_dmod* dmod,
int tag, SDM_options* sdmo= NULL);

void DM_get_attractor(int& rtn_err, DS_dmod* dmod, int
tag, double* image_pt, int& power, double& gain,
SDM_options* sdmo= NULL);

void DM_get_beta(int& rtn_err, DS_dmod* dmod, double*
beta, SDM_options* sdmo= NULL);

void DM_get_bspline_curve(int& rtn_err, DS_pfunc* pfunc,
    int& image_dim, int& degree, int& dof_count, int&
    knot_count, int*& knot_index, double*& knot,
    double*& dof_vec, double*& dof_def, int& end_cond, int&
    ntgrl_degree, SDM_options* sdmo= NULL);

void DM_get_bspline_surface(int& rtn_err, DS_pfunc*
    pfunc, int& image_dim, int& degree_u, int& dof_count_u,
    int& knot_count_u, int*& knot_index_u, double*&
    knot_u, int& degree_v, int& dof_count_v, int& knot_count_v,
    int*& knot_index_v, double*& knot_v, double*& dof_vec,
    double*& dof_def, int& end_cond_u, int& singular_u, int&
    end_cond_v, int& singular_v, int& ntgrl_degree, SDM_options* sdmo
    = NULL);

DS_dmod* DM_get_child(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

void DM_get_circ_curve(int& rtn_err, DS_pfunc* pfunc,
    int& image_dim, double*& dof_vec, double*& dof_def,
    int& elem_count, int& ntgrl_degree, SDM_options* sdmo=
    NULL);

void DM_get_comb_graphics(int& rtn_err, DS_dmod* dmod,
int& comb_pt_count, double& comb_gain, SDM_options* sdmo=
NULL);

void DM_get_cstrn(int& rtn_err, DS_dmod* dmod, int tag,
    DS_TAGS& type_id, DS_CSTRN_SRC& src_type, int& patch1_tag,
    int& patch2_tag, char* shape1, char* shape2, int& behavior,
    int& state, int& rights, void*& src1_data, void*&
    src2_data, int domain_flag, int& uv1_pts_count, int& uv2_pts_count,
    double uv1_pts[6], double uv2_pts[6], double&
    tang_gain, int& ntgrl_degree, SDM_options* sdmo= NULL);

int DM_get_cstrn_behavior(int& rtn_err, DS_dmod* dmod,
int tag, SDM_options* sdmo= NULL);

int DM_get_cstrn_rights(int& rtn_err, DS_dmod* dmod, int
tag, SDM_options* sdmo= NULL);

void* DM_get_cstrn_src_data(int& rtn_err, DS_dmod*
dmod, int tag, int tgt= 1, SDM_options* sdmo= NULL);

void DM_get_cstrn_src_pfuncs(int& rtn_err, DS_dmod*
    dmod, int tag, int tgt, DS_pfunc*& src_W_pfunc,
    DS_pfunc*& src_Wn_pfunc, DS_pfunc*& src_Wnn_pfunc,
    SDM_options* sdmo= NULL);

int DM_get_cstrn_state(int& rtn_err, DS_dmod* dmod, int
tag, SDM_options* sdmo= NULL);

void DM_get_cstrn_type_id(int& rtn_err, DS_dmod* dmod,
int tag, DS_TAGS& type_id, DS_CSTRN_SRC& src_type,
SDM_options* sdmo= NULL);

void DM_get_cstrn_value(int& rtn_err, DS_dmod* dmod, int
tag, int pt_index, int& cstrn_val_count, double*&
cstrn_val, SDM_options* sdmo= NULL);

void DM_get_curve_load(int& rtn_err, DS_dmod* dmod, int
tag, DS_pfunc*& src_C_pfunc, DS_pfunc*& src_W_pfunc,
double& gain, SDM_options* sdmo= NULL);

int DM_get_default_shape(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

double DM_get_delta(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

void DM_get_dist_press(int& rtn_err, DS_dmod* dmod, int
tag, int domain_flag, double* domain_min, double* domain_max,
double& gain, int& negate_flag, SDM_options* sdmo= NULL);

void DM_get_dmods(int& rtn_err, DS_dmod* dmod, int&
ntags, DM_tag_array& tags, SDM_options* sdmo= NULL);

DS_cstrn* DM_get_dmod_cstrn(int& rtn_err, DS_dmod*
dmod, SDM_options* sdmo= NULL);

void DM_get_dmod_curve(int& rtn_err, DS_dmod* dmod,
    double& domain_scale, DS_pfunc*& pfunc, void*&
    dmod_entity, int& draw_state, int& tag, double& alpha, double&
    beta, double& gamma, double& delta, double& dt, double&
    mass, double& damp, DS_dmod*& parent, DS_dmod*&
    sibling, DS_dmod*& child, int& load_count, int&
    cstrn_count, SDM_options* sdmo= NULL);

void DM_get_dmod_degree(int& rtn_err, DS_dmod* dmod,
int& u_degree, int& v_degree, SDM_options* sdmo= NULL);

void DM_get_dmod_domain_max(int& rtn_err, DS_dmod* dmod,
int domain_flag, double* domain_max, SDM_options* sdmo=
NULL);

void DM_get_dmod_domain_min(int& rtn_err, DS_dmod* dmod,
int domain_flag, double* domain_min, SDM_options* sdmo=
NULL);

double DM_get_dmod_domain_scale(int& rtn_err, DS_dmod*
dmod, SDM_options* sdmo= NULL);

void DM_get_dmod_knots(int& rtn_err, DS_dmod* dmod,
int& u_knot_count, double*& u_knot, int& v_knot_count,
double*& v_knot, SDM_options* sdmo= NULL);

DS_load* DM_get_dmod_load(int& rtn_err, DS_dmod*
dmod, SDM_options* sdmo= NULL);

DS_pfunc* DM_get_dmod_pfunc(int& rtn_err, DS_dmod*
dmod, SDM_options* sdmo= NULL);

void DM_get_dmod_surface(int& rtn_err, DS_dmod* dmod,
    void*& dmod_entity, double& domain_scale, DS_pfunc*& pfunc,
    int& draw_state, int& tag, double& au, double& av,
    double& atheta, double& bu, double& bv, double& btheta,
    double& gamma, double& delta, double& dt, double& mass,
    double& damp, DS_dmod*& parent, DS_dmod*& sibling,
    DS_dmod*& child, int& load_count, int& cstrn_count,
    SDM_options* sdmo= NULL);

int DM_get_dmod_tag(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

void DM_get_dmod_tags(int& rtn_err, DS_dmod* dmod,
int& ntags, DM_tag_array& tags, SDM_options* sdmo= NULL);

DS_TAGS DM_get_dmod_type_id(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

void DM_get_dof_state(int& rtn_err, DS_dmod* dmod,
    int& dof_count, int& free_count, int& cstrn_count, int&
    fixed_count, int& lambda_count, int& lfixed_count, SDM_options*
    sdmo= NULL);

int DM_get_domain_dim(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

void DM_get_draw_count(int& rtn_err, DS_dmod* dmod,
int& handle_count, int& shape_count, int walk_flag= 0,
SDM_options* sdmo= NULL);

int DM_get_draw_state(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

void DM_get_dynamics(int& rtn_err, DS_dmod* dmod,
double& dt, double& mass, double& damp, SDM_options* sdmo=
NULL);

void DM_get_elem_count(int& rtn_err, DS_dmod* dmod,
int& elem_count, int& u_span_count, int& v_span_count,
SDM_options* sdmo= NULL);

void DM_get_end_conds(int& rtn_err, DS_dmod* dmod,
int& end_cond_u, int& singular_u, int& end_cond_v, int&
singular_v, SDM_options* sdmo= NULL);

void* DM_get_entity(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

void DM_get_epsilon(int& rtn_err, const DS_dmod* dmod, int
tag, double& eps, SDM_options* sdmo= NULL);

double DM_get_gamma(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

DM_icon* DM_get_icon(int& rtn_err, DS_dmod* dmod, int
tag, SDM_options* sdmo= NULL);

int DM_get_image_dim(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

int DM_get_integral_degree(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

int DM_get_interior_state(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

double DM_get_load_gain(int& rtn_err, DS_dmod* dmod, int
tag, SDM_options* sdmo= NULL);

DS_TAGS DM_get_load_type_id(int& rtn_err, DS_dmod* dmod,
int tag, SDM_options* sdmo= NULL);

void DM_get_mesh_count(int& rtn_err, DS_dmod* dmod,
int& mesh_u, int& mesh_v, SDM_options* sdmo= NULL);

void DM_get_nurb_curve(int& rtn_err, DS_pfunc* pfunc,
    int& image_dim, int& degree, int& dof_count, int&
    knot_count, int*& knot_index, double*& knot,
    double*& dof_vec, double*& dof_def, double*& weight,
    int& end_cond, int& ntgrl_degree, SDM_options* sdmo= NULL
    );

void DM_get_nurb_surface(int& rtn_err, DS_pfunc* pfunc,
    int& image_dim, int& degree_u, int& dof_count_u, int&
    knot_count_u, int*& knot_index_u, double*& knot_u, int&
    degree_v, int& dof_count_v, int& knot_count_v, int*&
    knot_index_v, double*& knot_v, double*& dof_vec,
    double*& dof_def, double*& weight, int& end_cond_u, int&
    singular_u, int& end_cond_v, int& singular_v, int& ntgrl_degree,
    SDM_options* sdmo= NULL);

DS_dmod* DM_get_parent(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

int DM_get_patch_continuity(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

int DM_get_patch_seam_count(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

int DM_get_patch_seam_tag(int& rtn_err, DS_dmod* dmod,
int seam_number, SDM_options* sdmo= NULL);

int DM_get_pfunc_default_state(int& rtn_err, DS_pfunc*
pfunc, SDM_options* sdmo= NULL);

void DM_get_pfunc_degrees(int& rtn_err, DS_pfunc* pfunc,
DS_PFN& type_id, int& degree_u, int& degree_v, SDM_options*
sdmo= NULL);

void DM_get_pfunc_dofs(int& rtn_err, DS_pfunc* pfunc,
    DS_PFN& type_id, int& image_dim, int& dof_count_u, int&
    dof_count_v, double*& dof_vec, double*& dof_def,
    double*& weight, SDM_options* sdmo= NULL);

int DM_get_pfunc_dof_count(int& rtn_err, DS_pfunc*
pfunc, SDM_options* sdmo= NULL);

int DM_get_pfunc_domain_dim(int& rtn_err, DS_pfunc*
pfunc, SDM_options* sdmo= NULL);

void DM_get_pfunc_domain_max(int& rtn_err, DS_pfunc*
pfunc, int domain_flag, double* domain_max, SDM_options* sdmo
= NULL);

void DM_get_pfunc_domain_min(int& rtn_err, DS_pfunc*
pfunc, int domain_flag, double* domain_min, SDM_options* sdmo
= NULL);

int DM_get_pfunc_elem_count(int& rtn_err, DS_pfunc*
pfunc, SDM_options* sdmo= NULL);

int DM_get_pfunc_image_dim(int& rtn_err, DS_pfunc*
pfunc, SDM_options* sdmo= NULL);

void DM_get_pfunc_knots(int& rtn_err, DS_pfunc* pfunc,
    DS_PFN& type_id, int& u_knot_count, int& v_knot_count,
    double*& u_knots, int*& u_index, double*& v_knots,
    int*& v_index, SDM_options* sdmo= NULL);

void DM_get_pfunc_knot_counts(int& rtn_err, DS_pfunc*
pfunc, int& knot_count_u, int& knot_count_v, SDM_options*
sdmo= NULL);

DS_PFN DM_get_pfunc_type_id(int& rtn_err, DS_pfunc*
pfunc, SDM_options* sdmo= NULL);

void DM_get_pt_press(int& rtn_err, DS_dmod* dmod, int tag,
int domain_flag, double* dpt, double& gain, int&
negate_flag, SDM_options* sdmo= NULL);

void DM_get_pt_uv(int& rtn_err, DS_dmod* dmod, int tag, int
domain_flag, double* dpt, DS_TAGS& type, SDM_options* sdmo=
NULL);

void DM_get_pt_xyz(int& rtn_err, DS_dmod* dmod, int tag,
int pt_index, double* p0, DS_TAGS& type, SDM_options* sdmo
= NULL);

DS_dmod* DM_get_sibling(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

void DM_get_sibling_list(int& rtn_err, DS_dmod* dmod,
int& sibling_count, int*& sibling_list, SDM_options* sdmo
= NULL);

void DM_get_spring(int& rtn_err, DS_dmod* dmod, int tag,
int domain_flag, double* dpt, double* free_pt, double*
base_pt, double& gain, SDM_options* sdmo= NULL);

double DM_get_spring_length(int& rtn_err, DS_dmod* dmod,
int tag, SDM_options* sdmo= NULL);

void DM_get_spring_set(int& rtn_err, DS_dmod* dmod, int
    tag, int domain_flag, int& pt_count, double*& domain_pts,
    double*& free_pts, double*& base_pts, double& gain,
    SDM_options* sdmo= NULL);

void DM_get_tags(int& rtn_err, DS_dmod* dmod, int&
ntags, DM_tag_array& tags, SDM_options* sdmo= NULL);

int DM_get_tag_count(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

void DM_get_tag_summary(int& rtn_err, DS_dmod* dmod,
int& tag_count, int*& tag_summary, SDM_options* sdmo=
NULL);

double DM_get_tan_display_gain(int& rtn_err, DS_dmod*
dmod, SDM_options* sdmo= NULL);

int DM_get_tight_state(int& rtn_err, DS_dmod* dmod, int
tag, SDM_options* sdmo= NULL);

void DM_get_tolerance(int& rtn_err, double& dist_tol,
double& ang_tol, SDM_options* sdmo= NULL);

void DM_get_vector_load(int& rtn_err, DS_dmod* dmod, int
tag, double* image_vec, double& gain, SDM_options* sdmo
= NULL);

void DM_journal_off(int& rtn_err, SDM_options* sdmo=
NULL);

void DM_journal_on(int& rtn_err, char* file_name, int
cascade= 0, SDM_options* sdmo= NULL);

void DM_journal_play(int& rtn_err, char* file_name,
SDM_options* sdmo= NULL);

DS_pfunc* DM_make_bspline_curve(int& rtn_err, int
    image_dim, int degree, int dof_count, int knot_count, int* knot_index,
    double* knot, double* dof_vec, double* dof_def, int end_cond=
    0, SDM_options* sdmo= NULL);

DS_pfunc* DM_make_bspline_surface(int& rtn_err, int
    image_dim, int degree_u, int dof_count_u, int knot_count_u, int*
    knot_index_u, double* knot_u, int degree_v, int dof_count_v, int
    knot_count_v, int* knot_index_v, double* knot_v, double* dof_vec,
    double* dof_def, int end_cond_u= 0, int singular_u= 0, int
    end_cond_v= 0, int singular_v= 0, SDM_options* sdmo= NULL);

DS_pfunc* DM_make_circ_curve(int& rtn_err, int
image_dim, double* dof_vec, double u_min= 0.0, double u_max=
2* 3.1415926535898, SDM_options* sdmo= NULL);

DS_pfunc* DM_make_dcurve_image(int& rtn_err, int
domain_flag, double domain_scale, DS_pfunc* dcurve, DS_pfunc* surface,
double tolerance, SDM_options* sdmo= NULL);

DS_dmod* DM_make_dmod_curve(int& rtn_err, DS_pfunc*
    pfunc, void* dmod_entity= NULL, int draw_state=(1 <<
    1)|(1 << 2)|(1 << 3), int tag= 2, double alpha
    = 1.0, double beta= 5.0, double gamma= 0.0, double delta=
    0.0, double dt= 1.0, double mass= 0.0, double damp= 0.0,
    SDM_options* sdmo= NULL);

DS_dmod* DM_make_dmod_surface(int& rtn_err,
    DS_pfunc* pfunc, void* dmod_entity= NULL, int draw_state=(1
    << 1)|(1 << 2)|(1 << 3), int tag= 2,
    double au= 1.0, double av= 1.0, double atheta= 0.0, double bu
    = 5.0, double bv= 5.0, double btheta= 0.0, double gamma=
    0.0, double delta= 0.0, double dt= 1.0, double mass= 0.0,
    double damp= 0.0, SDM_options* sdmo= NULL);

DS_pfunc* DM_make_nurb_curve(int& rtn_err, int
    image_dim, int degree, int dof_count, int knot_count, int* knot_index,
    double* knot, double* dof_vec, double* dof_def, double*
    weight, int end_cond= 0, SDM_options* sdmo= NULL);

DS_pfunc* DM_make_nurb_surface(int& rtn_err, int
    image_dim, int degree_u, int dof_count_u, int knot_count_u, int*
    knot_index_u, double* knot_u, int degree_v, int dof_count_v, int
    knot_count_v, int* knot_index_v, double* knot_v, double* dof_vec,
    double* dof_def, double* weight, int end_cond_u= 0, int singular_u
    = 0, int end_cond_v= 0, int singular_v= 0, SDM_options*
    sdmo= NULL);

DS_pfunc* DM_make_orig_dmod_space_pfunc(int& rtn_err,
DS_dmod* dmod, SDM_options* sdmo= NULL);

void DM_param_max(int& rtn_err, DS_dmod* dmod, int tag,
DM_dbl_array& s_arr, SDM_options* sdmo= NULL);

void DM_param_min(int& rtn_err, DS_dmod* dmod, int tag,
DM_dbl_array& s_arr, SDM_options* sdmo= NULL);

DS_dmod* DM_parse_tag_flag(int& rtn_err, DS_dmod*
dmod, int tag_flag, int& walk_flag, SDM_options* sdmo= NULL
);

void DM_print_dmod(int& rtn_err, DS_dmod* dmod, FILE*
file, int walk_flag= 0, SDM_options* sdmo= NULL);

void DM_print_dmod_cstrns(int& rtn_err, DS_dmod* dmod,
FILE* file, SDM_options* sdmo= NULL);

void DM_query_icon(int& rtn_err, DM_icon_query_args&
args, DS_dmod* dmod, int tag, SDM_options* sdmo= NULL);

void DM_refine_dmod_fit(int& rtn_err, DS_dmod* dmod,
    double err_size, double& residual, double& beg_crv_dist_err,
    double& end_crv_dist_err, double& max_dist_moved, int walk_flag=
    0, SDM_options* sdmo= NULL);

void DM_rm_patch(int& rtn_err, DS_dmod* dmod, int
tag_flag, SDM_options* sdmo= NULL);

DS_TAGS DM_rm_tag_object(int& rtn_err, DS_dmod* dmod, int
tag, DS_dmod*&detached_dmod, int deletable_flag= 1,
SDM_options* sdmo= NULL);

void DM_scale_pfunc_image(int& rtn_err, DS_pfunc* pfunc,
double scale, SDM_options* sdmo= NULL);

void DM_scale_unit_dpt_array_from_dmod(int& rtn_err,
DS_dmod* dmod, int domain_dim, int pt_count, double* dpt,
SDM_options* sdmo= NULL);

void DM_scale_unit_dpt_array_from_pfunc(int& rtn_err,
DS_pfunc* pfunc, int domain_dim, int pt_count, double* dpt,
SDM_options* sdmo= NULL);

void DM_scale_unit_dpt_array_to_dmod(int& rtn_err,
DS_dmod* dmod, int domain_dim, int pt_count, double* dpt,
SDM_options* sdmo= NULL);

void DM_scale_unit_dpt_array_to_pfunc(int& rtn_err,
DS_pfunc* pfunc, int domain_dim, int pt_count, double* dpt,
SDM_options* sdmo= NULL);

void DM_scale_unit_dpt_from_dmod(int& rtn_err, DS_dmod*
dmod, int domain_dim, double* uv, SDM_options* sdmo= NULL);

void DM_scale_unit_dpt_from_pfunc(int& rtn_err,
DS_pfunc* pfunc, int domain_dim, double* uv, SDM_options* sdmo=
NULL);

void DM_scale_unit_dpt_to_dmod(int& rtn_err, DS_dmod*
dmod, int domain_dim, double* uv, SDM_options* sdmo= NULL);

void DM_scale_unit_dpt_to_pfunc(int& rtn_err, DS_pfunc*
pfunc, int domain_dim, double* uv, SDM_options* sdmo= NULL);

void DM_scale_unit_dvec_to_dmod(int& rtn_err, DS_dmod*
dmod, int domain_dim, double* duv, SDM_options* sdmo= NULL);

void DM_scale_unit_dvec_to_pfunc(int& rtn_err,
DS_pfunc* pfunc, int domain_dim, double* duv, SDM_options* sdmo=
NULL);

void DM_setstate_icon(int& rtn_err, const
DM_icon_cmd_args& args, DS_dmod* dmod, const int* tags, int ntags,
SDM_options* sdmo= NULL);

void DM_set_active_patch(int& rtn_err, DS_dmod* dmod,
SDM_options* sdmo= NULL);

void DM_set_alpha(int& rtn_err, DS_dmod* dmod,
double* alpha, int walk_flag= 0, SDM_options* sdmo= NULL);

void DM_set_area_cstrn_flag(int& rtn_err, DS_dmod* dmod,
int tag, int zone_flag, SDM_options* sdmo= NULL);

void DM_set_array_size(int& rtn_err, DM_dbl_array& arr,
int new_size, double init_val= 0.0, SDM_options* sdmo=
NULL);

void DM_set_attractor_power(int& rtn_err, DS_dmod* dmod,
int tag, int power= 2, SDM_options* sdmo= NULL);

void DM_set_beta(int& rtn_err, DS_dmod* dmod, double*
beta, int walk_flag= 0, SDM_options* sdmo= NULL);

int DM_set_comb_graphics(int& rtn_err, DS_dmod* dmod, int
comb_pt_count, double comb_gain, int walk_flag= 0, SDM_options* sdmo=
NULL);

void DM_set_cstrn_behavior(int& rtn_err, DS_dmod* dmod,
int tag, int behavior, SDM_options* sdmo= NULL);

void DM_set_cstrn_pttan_uv_dir(int& rtn_err, DS_dmod*
dmod, int tag, double* domain_dir, int which_dir, SDM_options*
sdmo= NULL);

void DM_set_cstrn_src_data(int& rtn_err, DS_dmod* dmod,
int tag, int tgt= 1, void* src_data= NULL, SDM_options*
sdmo= NULL);

void DM_set_cstrn_src_pfuncs(int& rtn_err, DS_dmod*
dmod, int tag, int tgt, DS_pfunc* src_W_pfunc, DS_pfunc*
src_Wn_pfunc, DS_pfunc* src_Wnn_pfunc, SDM_options* sdmo= NULL);

void DM_set_cstrn_state(int& rtn_err, DS_dmod* dmod, int
tag, int state_flag, SDM_options* sdmo= NULL);

void DM_set_cstrn_value(int& rtn_err, DS_dmod* dmod, int
    tag, int pt_index, DM_TANG_LEGDM_TANG1_LEGDM_TANG2_LEGDM_NORM_LEG
    DM_CURV1_LEGDM_CURV2_LEGDM_BINORM_LEGint cstrn_val_count, double*
    cstrn_val, SDM_options* sdmo= NULL);

void DM_set_default_shape(int& rtn_err, DS_dmod* dmod,
int shape_flag, int walk_flag= 0, SDM_options* sdmo= NULL
);

void DM_set_delta(int& rtn_err, DS_dmod* dmod, double
delta= 0.0, int walk_flag= 0, SDM_options* sdmo= NULL);

void DM_set_dmod_tag(int& rtn_err, DS_dmod* dmod, int tag,
SDM_options* sdmo= NULL);

int DM_set_draw_state(int& rtn_err, DS_dmod* dmod, int
draw_state, int walk_flag= 0 SDM_options* sdmo= NULL);

void DM_set_dynamics(int& rtn_err, DS_dmod* dmod, double
dt= 1.0, double mass= 1.0, double damp= 5.0, int walk_flag
= 0, SDM_options* sdmo= NULL);

void DM_set_end_conds(int& rtn_err, DS_dmod* dmod, int
end_cond_u, int singular_u, int end_cond_v, int singular_v, SDM_options*
sdmo= NULL);

void DM_set_entity(int& rtn_err, DS_dmod* dmod, void*
entity, SDM_options* sdmo= NULL);

void DM_set_epsilon(int& rtn_err, DS_dmod* dmod, int tag,
double eps, SDM_options* sdmo= NULL);

void DM_set_gamma(int& rtn_err, DS_dmod* dmod, double
gamma= 0.0, int walk_flag= 0, SDM_options* sdmo= NULL);

void DM_set_icon(int& rtn_err, DS_dmod* dmod, int tag,
DM_icon* dmicon, SDM_options* sdmo= NULL);

void DM_set_icon_owner(int& rtn_err, DS_dmod* dmod, const
int* tags, int ntags, SDM_options* sdmo= NULL);

void DM_set_interior_state(int& rtn_err, DS_dmod* dmod,
int interior_state, int walk_flag, SDM_options* sdmo= NULL);

void DM_set_load_gain(int& rtn_err, DS_dmod* dmod,
DS_TAGS& type, int tag, double gain, int group_flag= 0, int inc_flag=
0, SDM_options* sdmo= NULL);

int DM_set_mesh_count(int& rtn_err, DS_dmod* dmod, int
mesh_u, int mesh_v, int walk_flag= 0, SDM_options* sdmo= NULL);

void DM_set_patch_continuity(int& rtn_err, DS_dmod*
dmod, int continuity, SDM_options* sdmo= NULL);

void DM_set_pfunc_default_state(int& rtn_err, DS_pfunc*
pfunc, int default_state, SDM_options* sdmo= NULL);

DS_TAGS DM_set_pt_uv(int& rtn_err, DS_dmod* dmod, int tag,
int domain_flag, double* dpt, SDM_options* sdmo= NULL);

DS_TAGS DM_set_pt_xyz(int& rtn_err, DS_dmod* dmod, int
    tag, int pt_index, DM_END_LEGDM_TANG_LEGDM_TANG1_LEGDM_TANG2_LEG
    DM_NORM_LEGDM_CURV1_LEGDM_CURV2_LEGDM_BINORM_LEGdouble* p0,
    double* p1, int dir_flag, 1=move parallel toxy plane, 2=move
    parallel toz axis.1=rotate current2=change vectorint cascade_flag
    = 1, 1=update related0=don't.int curvature_sign=
    0, dir_flag ==0 &&domain_dim==2 &&
    PT_index==PST_CURV1or PST_CURV2.k * n, (k positive), -k * -n, (k negative),
    SDM_options* sdmo= NULL);

void DM_set_tag_count(int& rtn_err, DS_dmod* dmod, int
tag_count, SDM_options* sdmo= NULL);

void DM_set_tan_display_gain(int& rtn_err, DS_dmod*
dmod, double tan_display_gain= 1.0, int walk_flag= 0,
SDM_options* sdmo= NULL);

void DM_set_tight_state(int& rtn_err, DS_dmod* dmod, int
tag, int state_flag, SDM_options* sdmo= NULL);

void DM_set_tolerance(int& rtn_err, double dist_tol, double
ang_tol, SDM_options* sdmo= NULL);

void DM_solve(int& rtn_err, DS_dmod* dmod, int iter_count
= 1, double max_move= 0.0, SDM_options* sdmo= NULL);

void DM_split_dmod(int& rtn_err, DS_dmod* dmod, int
domain_flag, int split_pt_count, double* split_pts, SDM_options* sdmo
= NULL);

void DM_update_cstrn_src_pts(int& rtn_err, DS_dmod*
dmod, int tag, SDM_options* sdmo= NULL);

void DM_xsect_dmod_by_image_line(int& rtn_err, DS_dmod*
    dmod, int walk_flag, double* p0, double* p1, double max_dist,
    double& image_line_u, int domain_flag, double* domain_pt, double*
    image_pt, SDM_options* sdmo= NULL);

spline* extend_spline( spline const& spl, double dist);

ATTRIB* find_attrib( ENTITY const* owner, int subtype=
-1, int subsubtype= -1, int subsubsubtype= -1, int
subsubsubsubtype= -1);

char const* find_err_ident( err_mess_type err_num);

char const* find_err_mess( err_mess_type err_num);

double find_face_face_distance( FACE* face1, FACE* face2,
    SPAposition& p1, SPAposition& p2, param_info& ent1_info
    =*(param_info*)NULL_REF, param_info& ent2_info=*(param_info*)NULL_REF
    );

ID_ATTRIB* find_ID_ATTRIB( ENTITY* ent);

ATTRIB* find_leaf_attrib( ENTITY const* owner, int
attrib_type);

option_header* find_option(char const* name);

PART* find_part(unsigned int id);

int get_ATTRIB_BLEND_TYPE();

int get_ATTRIB_SYS_TYPE();

attrib_tag_callbacks_list&
get_attrib_tag_callbacks_list();

int get_ATTRIB_TSL_TYPE();

bounded_curve* get_bounded_curve( EDGE* edge, logical
apply_transf= TRUE);

logical get_curve_center( EDGE* crv, SPAposition& center
);

HISTORY_STREAM* get_default_stream(logical make_if_null
= TRUE);

SPAbox get_edge_box( EDGE* this_edge, SPAtransf const* t
= NULL, logical tight_box= FALSE, SPAbox* untransformed_box
= NULL);

entity_callback_list& get_entity_callback_list();

SPAbox get_face_box( FACE* this_face, SPAtransf const* t
= NULL, logical tight_box= FALSE, SPAbox* untransformed_box
= NULL);

int get_major_version();

int get_minor_version();

PART* get_next_part(int& index);

option_header* get_option_list();

PART* get_part(const ENTITY* ent);

PART_CONTEXT* get_part_context(const ENTITY* ent);

double get_resabs();

double get_resfit();

double get_resmch();

double get_resnor();

roll_callback_list& get_roll_callback_list();

FileInterface* get_savres_file();

scheme_error_callback_list&
get_scheme_error_callback_list();

ENTITY* get_Scm_Entity( ScmObject e);

SPAvector get_Scm_Gvector( ScmObject sp);

law* get_Scm_Law( ScmObject r);

SPAposition get_Scm_Position( ScmObject sp);

const char* get_Scm_String( ScmObject s);

SPAtransf get_Scm_Transform( ScmObject t);

logical get_wire_plane( WIRE* this_wire, SPAposition&
centroid, SPAunit_vector& normal, logical apply_transf= TRUE);

logical initialize_base( base_configuration* base_config
= NULL);

logical initialize_law();

SPAposition interpolate(double param, SPAposition const& p1,
SPAposition const& p2);

int intersect_line_circle(const SPAposition& line_pt, const
SPAunit_vector& line_dir, const SPAposition& center, const
SPAunit_vector& normal, double radius, SPAposition* intpts);

int intersect_line_plane(const SPAposition& line_point,
    const SPAvector& line_vector, const SPAposition& plane_point,
    const SPAunit_vector&plane_normal, double& line_param,
    SPAposition&intersection_position);

int intersect_plane_plane(const SPAposition& p1, const
SPAunit_vector& n1, const SPAposition& p2, const SPAunit_vector& n2,
SPAposition& line_pt, SPAunit_vector& line_dir);

logical is_ANNOTATION(const ENTITY* e);

logical is_APOINT(const ENTITY* ent);

logical is_ATTRIB(const ENTITY* ent);

logical is_ATTRIB_AGC(const ENTITY* e);

logical is_ATTRIB_ANNOTATION(const ENTITY* e);

logical is_ATTRIB_BLEND(const ENTITY* e);

logical is_ATTRIB_BLINFO(const ENTITY* e);

logical is_ATTRIB_CELL(const ENTITY* e);

logical is_ATTRIB_CFACE_VOL(const ENTITY* e);

logical is_ATTRIB_COL(const ENTITY* e);

logical is_ATTRIB_CONST_CHAMFER(const ENTITY* e);

logical is_ATTRIB_CONST_ROUND(const ENTITY* e);

logical is_ATTRIB_CT(const ENTITY* e);

logical is_ATTRIB_DC2ACIS(const ENTITY* e);

logical is_ATTRIB_DM2ACIS(const ENTITY* e);

logical is_ATTRIB_DS2ACIS(const ENTITY* e);

logical is_ATTRIB_EFINT(const ENTITY* e);

int is_ATTRIB_EYE(const ENTITY* e);

int is_ATTRIB_EYE_ATTACHED_MESH(const ENTITY* e);

logical is_ATTRIB_FACECFACE(const ENTITY* e);

logical is_ATTRIB_FACEINT(const ENTITY* e);

logical is_ATTRIB_FFBLEND(const ENTITY* e);

logical is_ATTRIB_GENERIC(const ENTITY* e);

logical is_ATTRIB_GEN_ENTITY(const ENTITY* e);

logical is_ATTRIB_GEN_INTEGER(const ENTITY* e);

logical is_ATTRIB_GEN_NAME(const ENTITY* e);

logical is_ATTRIB_GEN_POINTER(const ENTITY* e);

logical is_ATTRIB_GEN_POSITION(const ENTITY* e);

logical is_ATTRIB_GEN_REAL(const ENTITY* e);

logical is_ATTRIB_GEN_STRING(const ENTITY* e);

logical is_ATTRIB_GEN_VECTOR(const ENTITY* e);

logical is_ATTRIB_HH_AGGR_ANALYTIC(const ENTITY* e);

logical is_ATTRIB_HH_AGGR_GEN_SPLINE(const ENTITY* e);

logical is_ATTRIB_HH_AGGR_GEOMBUILD(const ENTITY* e);

int is_ATTRIB_HH_AGGR_GEOMBUILD_BASE(const ENTITY* e);

logical is_ATTRIB_HH_AGGR_ISOSPLINE(const ENTITY* e);

logical is_ATTRIB_HH_AGGR_SHARP_EDGE(const ENTITY* e);

int is_ATTRIB_HH_AGGR_SIMPLIFY(const ENTITY* e);

int is_ATTRIB_HH_AGGR_SIMPLIFY_BASE(const ENTITY* e);

logical is_ATTRIB_HH_AGGR_WRAPUP(const ENTITY* e);

int is_ATTRIB_HH_ENT_GEOMBUILD_BASE(const ENTITY* e);

int is_ATTRIB_HH_ENT_GEOMBUILD_COEDGE(const ENTITY* e);

logical is_ATTRIB_HH_ENT_GEOMBUILD_CURVE(const ENTITY* e);

int is_ATTRIB_HH_ENT_GEOMBUILD_EDGE(const ENTITY* e);

int is_ATTRIB_HH_ENT_GEOMBUILD_FACE(const ENTITY* e);

logical is_ATTRIB_HH_ENT_GEOMBUILD_LOOP(const ENTITY* e);

logical is_ATTRIB_HH_ENT_GEOMBUILD_SURFACE(const ENTITY* e
);

int is_ATTRIB_HH_ENT_GEOMBUILD_VERTEX(const ENTITY* e);

logical is_ATTRIB_HH_ENT_SIMPLIFY_BASE(const ENTITY* e);

logical is_ATTRIB_HH_ENT_SIMPLIFY_FACE(const ENTITY* e);

logical is_ATTRIB_INTCOED(const ENTITY* e);

logical is_ATTRIB_INTEDGE(const ENTITY* e);

logical is_ATTRIB_INTGRAPH(const ENTITY* e);

logical is_ATTRIB_INTVERT(const ENTITY* e);

logical is_ATTRIB_PHL(const ENTITY* e);

logical is_ATTRIB_PHL_VW(const ENTITY* e);

logical is_ATTRIB_RGB(const ENTITY* e);

logical is_ATTRIB_ST(const ENTITY* ent);

logical is_ATTRIB_SYS(const ENTITY* e);

logical is_ATTRIB_TAG(const ENTITY* e);

logical is_ATTRIB_TSL(const ENTITY* e);

logical is_ATTRIB_VAR_BLEND(const ENTITY* e);

logical is_ATTRIB_VBLEND(const ENTITY* e);

logical is_ATTRIB_VOL_COL(const ENTITY* e);

logical is_ATT_BL_INST(const ENTITY* e);

logical is_Background_Type(const char* type);

logical is_BLEND_ANNOTATION(const ENTITY* e);

logical is_BLEND_ANNO_EDGE(const ENTITY* e);

logical is_BODY(const ENTITY* ent);

logical is_CELL(const ENTITY* e);

logical is_CELL2D(const ENTITY* e);

logical is_CELL3D(const ENTITY* e);

logical is_CFACE(const ENTITY* e);

logical is_circular_edge(const ENTITY* ent);

logical is_closed_curve( EDGE* crv);

logical is_COEDGE(const ENTITY* ent);

logical is_Color_Type(const char* type);

logical is_CONE(const ENTITY* ent);

logical is_cone(const surface* surf);

logical is_conical_face(const ENTITY* ent);

logical is_CSHELL(const ENTITY* e);

logical is_CURVE(const ENTITY* ent);

logical is_curve_edge(const ENTITY* ent);

logical is_cylindrical_face(const ENTITY* ent);

logical is_Displace_Type(const char* type);

logical is_EDGE(const ENTITY* ent);

logical is_EE_LIST(const ENTITY* e);

logical is_ELLIPSE(const ENTITY* ent);

logical is_ellipse(const curve* crv);

logical is_elliptical_edge(const ENTITY* ent);

int is_ENTITY(const ENTITY*);

logical is_ENTITY_IHL(const ENTITY* e);

logical is_ENTITY_PHL(const ENTITY* e);

logical is_equal(const SPAposition& p1, const
SPAposition& p2);

logical is_FACE(const ENTITY* ent);

logical is_Foreground_Type(const char* type);

logical is_greater_than(double n1, double n2);

logical is_ID_ATTRIB(const ENTITY* e);

logical is_IHL_CAMERA(const ENTITY* e);

logical is_IHL_SEGMENT(const ENTITY* e);

logical is_INTCURVE(const ENTITY* ent);

logical is_intcurve(const curve* crv);

logical is_intcurve_edge(const ENTITY* ent);

logical is_LAW(const ENTITY* ent);

logical is_less_than(double n1, double n2);

logical is_Light_Type(const char* type);

logical is_linear_edge(const ENTITY* ent);

logical is_LOOP(const ENTITY* ent);

logical is_LUMP(const ENTITY* ent);

logical is_NAMED_ATTRIB(const ENTITY* e);

logical is_NAMED_INT_ATTRIB(const ENTITY* e);

logical is_NAMED_LOGICAL_ATTRIB(const ENTITY* e);

logical is_NAMED_POS_ATTRIB(const ENTITY* e);

logical is_NAMED_REAL_ATTRIB(const ENTITY* e);

logical is_NAMED_STRING_ATTRIB(const ENTITY* e);

logical is_NAMED_VEC_ATTRIB(const ENTITY* e);

logical is_negative(double n);

logical is_NORENDER_ATTRIB(const ENTITY* e);

logical is_NO_MERGE_ATTRIB(const ENTITY* e);

logical is_on_line(const SPAposition& pt, const
SPAposition& line_pt, const SPAunit_vector& line_dir);

logical is_on_plane(const SPAposition& pt, const
SPAposition& plane_pt, const SPAunit_vector& normal);

logical is_PCURVE(const ENTITY* ent);

logical is_PHLV5_EDGE(const ENTITY* e);

logical is_PHLV5_SEGMENT(const ENTITY* e);

logical is_PHL_CAMERA(const ENTITY* e);

logical is_PHL_EDGE(const ENTITY* e);

logical is_PHL_SEGMENT(const ENTITY* e);

logical is_planar_face(const ENTITY* ent);

logical is_planar_wire( COEDGE* this_coedge,
SPAposition& centroid, SPAunit_vector& normal, logical apply_transf=
TRUE);

logical is_PLANE(const ENTITY* ent);

logical is_plane(const surface* surf);

logical is_positive(double n);

logical is_PRIMITIVE_ANNOTATION(const ENTITY* e);

int is_REFINEMENT(const ENTITY* e);

logical is_Reflect_Type(const char* type);

logical is_RH_BACKGROUND(const ENTITY* e);

logical is_RH_ENTITY(const ENTITY* e);

logical is_RH_ENVIRONMENT_MAP(const ENTITY* e);

logical is_RH_FOREGROUND(const ENTITY* e);

logical is_RH_LIGHT(const ENTITY* e);

logical is_RH_MATERIAL(const ENTITY* e);

logical is_RH_TEXTURE_SPACE(const ENTITY* e);

logical is_Scm_Entity( ScmObject e);

logical is_Scm_Entray( ScmObject r);

logical is_Scm_Real_List( ScmObject list);

logical is_SHELL(const ENTITY* ent);

logical is_solid_body(const ENTITY* ent);

logical is_SPAGROUP(const ENTITY* e);

logical is_SPHERE(const ENTITY* ent);

logical is_sphere(const surface* surf);

logical is_spherical_face(const ENTITY* ent);

logical is_SPLINE(const ENTITY* ent);

logical is_spline(const surface* surf);

logical is_spline_face(const ENTITY* ent);

logical is_STRAIGHT(const ENTITY* ent);

logical is_straight(const curve* crv);

logical is_SUBSHELL(const ENTITY* ent);

logical is_SURFACE(const ENTITY* ent);

logical is_SWEEP_ANNO_EDGE_LAT(const ENTITY* e);

logical is_SWEEP_ANNO_END_CAPS(const ENTITY* e);

logical is_TCOEDGE(const ENTITY* e);

logical is_TEDGE(const ENTITY* e);

logical is_Texture_Space_Type(const char* type);

logical is_TEXT_ANNOTATION(const ENTITY* e);

logical is_TEXT_ENT(const ENTITY* ent);

logical is_toplevel(const ENTITY* ent);

logical is_toroidal_face(const ENTITY* ent);

logical is_TORUS(const ENTITY* ent);

logical is_torus(const surface* surf);

logical is_TRANSFORM(const ENTITY* e);

logical is_Transp_Type(const char* type);

logical is_TVERTEX(const ENTITY* e);

logical is_UNDEFC(const ENTITY* e);

logical is_UNITS_SCALE(const ENTITY* ent);

logical is_VERTEX(const ENTITY* ent);

int is_VERTEX_TEMPLATE(const ENTITY* e);

logical is_WARP_ANNOTATION(const ENTITY* e);

logical is_WARP_ANNO_FACE(const ENTITY* e);

logical is_WCS(const ENTITY* ent);

logical is_WIRE(const ENTITY* ent);

logical is_wire_body(const ENTITY* ent);

logical is_zero(const SPAposition& p);

FACE* make_face_spline( surface const &this_surface,
curve const &bottom_cur, curve const &top_cur, curve const
&left_cur, curve const &right_cur, SPApar_box const &pb);

ScmObject make_Scm_Entity( ENTITY* ent);

SURFACE* make_surface( surface const& this_surface);

int new_law_id();

unit_vector normalise( SPAvector const& v);

logical parallel( SPAunit_vector const& v1, SPAunit_vector
const& v2, const double res= SPAresnor);

logical perpendicular( SPAunit_vector const& v1,
SPAunit_vector const& v2, const double res= SPAresnor);

SPAposition proj_pt_to_line(const SPAposition& pt, const
SPAposition& line_pt, const SPAunit_vector& line_dir);

SPAposition proj_pt_to_plane(const SPAposition& pt, const
SPAposition& c, const SPAunit_vector& n);

hit* raytest_edge( ray& this_ray, EDGE* this_edge);

hit* raytest_face( ray& this_ray, FACE* this_face);

ENTITY* read_array( ENTITY* array[], int i);

int read_char();

TaggedData* read_data();

int read_enum( enum_table const& tbl);

float read_float();

logical read_header(int& i1, int& i2, int& i3, int&
i4);

int read_id(char* buf, int buflen= 0);

int read_int();

SPAinterval read_interval();

logical read_logical(char const* false_str= "F",
char const* true_str= "T");

long read_long();

SPAmatrix read_matrix();

void* read_pointer();

SPAposition read_position();

ENTITY* read_ptr();

double read_real();

int read_sequence();

char* read_string(int& len);

logical read_subtype_end();

logical read_subtype_start();

SPAtransf read_transf();

SPAunit_vector read_unit_vector();

SPAvector read_vector();

SPAtransf reflect_transf( SPAvector const& axis);

void refresh_all();

void remove_rbase_app_cb( rbase_app_callback* cb);

void reset_boxes( ENTITY* this_entity);

void reset_boxes_downward( ENTITY* ent);

curve* restore_curve();

SPAtransf rotate_transf(double angle, SPAvector const& axis);

logical same_matrix( SPAmatrix const& m1, matrix SPAmatrix
const& m2, const double res= SPAresabs);

logical same_vector( SPAvector const& v1, SPAvector const&
v2, const double res= SPAresabs);

SPAtransf scale_transf(double scale);

SPAmatrix scaling(double factor);

int SchemeEvaluate( ScmObject expr, ScmObject& result);

int SchemeLoad(const char* filename);

int scheme_process(const char* inpLine, int echo);

void set_logging(logical onoff);

void sg_add_pcurves_to_entity( ENTITY* ent);

SPAtransf& sg_get_transform( ENTITY* entity);

void sg_split_edge_at_convexity( EDGE* edge);

void sg_split_edge_at_vertex( EDGE* edge, VERTEX*
new_vertex, ENTITY_LIST& coedge_list=
*(ENTITY_LIST*)NULL_REF, logical split_geometry=FALSE);

void start_entity_creation();

void start_entity_modification();

logical terminate_base();

logical terminate_law();

SPAposition to_model(const SPAposition& pt);

SPAposition to_wcs(const SPAposition& pt);

SPAtransf translate_transf( SPAvector const& disp);

SPAtransf wcs_active_to_model();

WCS* wcs_get_active();

SPAtransf wcs_model_to_active();

SPAposition wcs_origin();

outcome wcs_set_origin( WCS* wcs, const SPAposition&
new_origin);

SPAunit_vector wcs_x_axis();

SPAunit_vector wcs_y_axis();

SPAunit_vector wcs_z_axis();