|
double angle_between(const SPAunit_vector& v1, const SPAunit_vector& v2, const SPAunit_vector& z = *(SPAunit_vector*)NULL_REF)
|
|
|
double angle_between(const SPAvector& v1, const SPAvector& v2, const SPAunit_vector& z = *(SPAunit_vector*)NULL_REF)
|
|
|
outcome api_abort_state(HISTORY_STREAM* hs = NULL)
|
|
|
outcome api_add_state(DELTA_STATE* ds, HISTORY_STREAM* hs)
|
|
|
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, const SPAvector& scale1, const SPAvector& scale2, int which_dim, const SPAposition& root, 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_calculate_edge_tolerance(EDGE* edge, double& tol, AcisOptions* ao = NULL)
|
|
|
outcome api_calculate_vertex_tolerance(VERTEX* vertex, double& tol, 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_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_face_loops(FACE* in_face, int ai_info[] = NULL, AcisOptions* ao = NULL)
|
|
|
outcome api_check_histories(HISTORY_STREAM_LIST* insane_list, FILE* fptr)
|
|
|
logical api_check_on()
|
|
|
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_clear_annotations(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_create_history(HISTORY_STREAM*& hs)
|
|
|
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_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_cylindrical_pattern(pattern*& pat, const SPAposition& center, const SPAvector& normal, 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_ds(DELTA_STATE* ds)
|
|
|
outcome api_delete_history(HISTORY_STREAM* hs = 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_distribute_state_to_streams(DELTA_STATE* pState, StreamFinder* pStreamFinder, logical clearDelta, logical hideStates)
|
|
|
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 = *(SPAvector*)NULL_REF, AcisOptions* ao = NULL)
|
|
|
outcome api_edge_pattern(pattern*& pat, EDGE* in_edge, FACE* in_face, int number, const SPAposition& root, logical on_endpoints = FALSE, const SPAvector& normal_dir = *(SPAvector*)NULL_REF, const SPAvector& tangent_dir = *(SPAvector*)NULL_REF, AcisOptions* ao = NULL)
|
|
|
outcome api_edge_pattern(pattern*& pat, EDGE* in_edge, int number, const SPAposition& root, logical on_endpoints = FALSE, const SPAvector& rail_dir = *(SPAvector*)NULL_REF, const SPAvector& tangent_dir = *(SPAvector*)NULL_REF, 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_end_journal(AcisOptions* ao)
|
|
|
outcome api_ensure_empty_root_state(HISTORY_STREAM* history, DELTA_STATE*& root_state)
|
|
|
outcome api_extract_coed_info(COEDGE* coedge, logical forward, logical outward, int num_pts, SPAposition* pts, SPAunit_vector* tans)
|
|
|
outcome api_find_annotations(ENTITY_LIST&, is_fun = is_ANNOTATION, BULLETIN_BOARD* bb = NULL, AcisOptions* = NULL)
|
|
|
outcome api_find_named_state(const char* name, HISTORY_STREAM* hs, DELTA_STATE_LIST& dslist)
|
|
|
outcome api_get_active_entities(HISTORY_STREAM const* hs, ENTITY_LIST& ents, logical unowned_only = FALSE, AcisOptions* ao = NULL)
|
|
|
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_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_edges(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& entlist, ENTITY_ID topological_bits, ENTITY_ID geometrical_bits, 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_faces(ENTITY* ent, ENTITY_LIST& face_list, PAT_NEXT_TYPE include_pat = PAT_CAN_CREATE, 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_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_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_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_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_version_tag(int major, int minor, int point, int& tag)
|
|
|
outcome api_get_version_tag(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_wires(ENTITY* ent, ENTITY_LIST& out_list, PAT_NEXT_TYPE include_pat = PAT_CAN_CREATE, 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_cylindrical_pattern(pattern*& pat, const SPAposition& center, const SPAvector& normal, 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_hook_annotations(is_fun is_function = is_ANNOTATION, BULLETIN_BOARD* bb = NULL, AcisOptions* ao = NULL)
|
|
|
outcome api_initialize_kernel()
|
|
|
outcome api_initialize_spline()
|
|
|
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(law* integrand, double start, double end, int wrt, double* along, double* answer, double tol, int min_level, int* used_level)
|
|
|
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_integrate_law_wrt_and_splits(law* integrand, double start, double end, int wrt, double* along, double* answer, int number_of_splits, double* splits, double tol, int min_level, int* used_level)
|
|
|
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, const SPAvector& first_scale, const SPAvector& last_scale, int which_dim, const SPAposition& root, logical merge = TRUE, 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_logging(logical on_off)
|
|
|
outcome api_loop_type(LOOP* in_loop, loop_type& type, int info[] = NULL)
|
|
|
outcome api_make_cubic(double aval, double bval, double faval, double fbval, double ffaval, double ffbval, law*& answer)
|
|
|
outcome api_make_linear(double aval, double bval, double faval, double fbval, law*& answer)
|
|
|
outcome api_make_polynomial_law(double* coeff, int degree, law*& answer)
|
|
|
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_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_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)
|
|
|
outcome api_make_version_object(AcisVersion*& av, int major, int minor, int point)
|
|
|
outcome api_make_version_object(AcisVersion*& av, int tag)
|
|
|
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_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_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_optimize_tvertex_tolerance(EDGE* this_edge, AcisOptions* ao = NULL)
|
|
|
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 SPAvector* scale, int period, int which_dim, const SPAposition& root, 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_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_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_prune_following(HISTORY_STREAM* hs)
|
|
|
outcome api_prune_history(HISTORY_STREAM* hs, DELTA_STATE* ds = NULL)
|
|
|
outcome api_query_state_validity(DELTA_STATE* ds, logical& change_state_possible, HISTORY_STREAM* hs = 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, const SPAinterval& axial_range, const SPAvector& axial_dir, const SPAinterval& tilt_range, const SPAvector& tilt_dir, AcisOptions* ao)
|
|
|
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* = NULL)
|
|
|
outcome api_random_pattern(pattern*& pat, const SPAvector& extents, int num_elements, int dimension, logical ellipsoidal, const SPAvector& x_vec, const SPAvector& y_vec, AcisOptions* ao)
|
|
|
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* = NULL)
|
|
|
outcome api_random_scale_pattern(pattern*& pat, const pattern& in_pattern, const SPAvector& min_scale, const SPAvector& max_scale, const SPAposition& root, logical merge = TRUE, 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_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_replace_edge_with_tedge(EDGE* this_edge, TEDGE*& this_tedge, 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_roll_n_states(HISTORY_STREAM* hs, int nRequest, int& nActual)
|
|
|
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_set_acis_options(AcisOptions* ao, AcisJournal& aj = *(AcisJournal*)NULL_REF, AcisVersion& av = *(AcisVersion*)NULL_REF)
|
|
|
outcome api_set_dbl_option(char const* name, double value)
|
|
|
outcome api_set_default_history(HISTORY_STREAM* hs)
|
|
|
outcome api_set_file_info(unsigned long, FileInfo const& info)
|
|
|
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_journal_name(AcisOptions* ao, char* name)
|
|
|
outcome api_set_str_option(char const* name, char const* value)
|
|
|
outcome api_set_version(AcisOptions* ao, AcisVersion& av)
|
|
|
outcome api_spherical_pattern(pattern*& pat, const SPAposition& center, int num_latitudes, const SPAposition& root, double spacing = 0.0, AcisOptions* ao = NULL)
|
|
|
outcome api_stackmon_limit(size_t limit)
|
|
|
outcome api_start_journal(AcisOptions* ao)
|
|
|
outcome api_start_modeller(int)
|
|
|
outcome api_stop_modeller()
|
|
|
outcome api_str_to_law(const char* str, law** answer, law_data** data = NULL, int size = 0, 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_surface_pattern(pattern*& pat, const surface& in_surf, const SPApar_box& face_range, 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, const SPAtransf& in_trans = *(SPAtransf*)NULL_REF, AcisOptions* ao = NULL)
|
|
|
outcome api_terminate_kernel()
|
|
|
outcome api_terminate_spline()
|
|
|
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_unhook_annotations(is_fun is_function = is_ANNOTATION, BULLETIN_BOARD* bb = NULL, AcisOptions* ao = NULL)
|
|
|
outcome api_update_tolerance(ENTITY* this_entity, logical& updated, AcisOptions* ao = 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)
|
|
|
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()
|
|
|
static bs2_curve bs2_curve_interp(int npts, SPApar_pos const pts[], double const knots[])
|
|
|
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)
|
|
|
void bs2_curve_to_array(bs2_curve, int&, int&, logical&, int&, SPAposition*&, double* &, int&, double* &)
|
|
|
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(SPAinterval u_range, bs2_curve_form form, double v)
|
|
|
bs2_curve bs2_curve_u_param_line(bs3_surface surf, double v)
|
|
|
bs2_curve bs2_curve_v_param_line(SPAinterval v_range, bs2_curve_form form, double u)
|
|
|
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)
|
|
|
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)
|
|
|
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_dist(const bs3_curve bs, double dist, logical to_right, logical make_seg_list, bs3_offset_seg*& seg_list, 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& acis_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)
|
|
|
SPAposition bs3_curve_position(double param, bs3_curve cur)
|
|
|
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)
|
|
|
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)
|
|
|
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)
|
|
|
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, int j, 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& par_bx = *(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)
|
|
|
int bs3_surface_evaluate(SPApar_pos const& uv, bs3_surface sur, SPAposition& pos, SPAvector** deriv, int nuderiv, int nvderiv, int uindex, int vindex)
|
|
|
bs3_surface bs3_surface_fit(double fittol, int num_u, int num_v, const SPAposition pts[], const SPAunit_vector du_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 SPAposition ctrlpts[], 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_vector du_s[], const SPAunit_vector du_e[], const SPAunit_vector dv_s[], const SPAunit_vector dv_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, SPApar_box const& subset_range = *(SPApar_box*)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)
|
|
|
bs3_surface bs3_surface_proc(int num_u_knots, double* u_knots, int num_v_knots, double* v_knots, 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, int max_iters, int& number_of_iterations)
|
|
|
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, bs3_curve v_bs, double = 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 compute_axes_from_z(const SPAunit_vector& z_axis, SPAunit_vector& x_axis, SPAunit_vector& y_axis)
|
|
|
BULLETIN_BOARD* current_bb()
|
|
|
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_new_pointer(char const* title, 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)
|
|
|
logical dist_pt_to_line(SPAposition const& pt, SPAposition const& line_pt, SPAvector const& line_vec, double& dist, double& line_prm)
|
|
|
spline* extend_spline(spline const& spl, SPApar_box const& range)
|
|
|
spline* extend_spline(spline const& spl, double dist)
|
|
|
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)
|
|
|
ATTRIB* find_leaf_attrib(ENTITY const* owner, int attrib_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)
|
|
|
bounded_curve* get_bounded_curve(TCOEDGE* tcoedge, 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 = 0, SPAbox* untransformed_box = NULL)
|
|
|
SPAbox get_face_box(FACE* this_face, SPAtransf const* t = NULL, logical tight_box = 0, SPAbox* untransformed_box = NULL)
|
|
|
FileInterface* get_savres_file()
|
|
|
ENTITY* get_Scm_Entity(ScmObject e)
|
|
|
ENTITY* get_Scm_Entity(ScmObject o, const entity_filter& filt, const char* type)
|
|
|
ENTITY* get_Scm_Entity(ScmObject o, entity_test_proc test, const char* type)
|
|
|
SPAvector get_Scm_Gvector(ScmObject sp)
|
|
|
law* get_Scm_Law(ScmObject r)
|
|
|
SPAposition get_Scm_Position(ScmObject sp)
|
|
|
SPAtransf get_Scm_Transform(ScmObject t)
|
|
|
logical get_wire_plane(WIRE* this_wire, SPAposition& centroid, SPAunit_vector& normal, logical apply_transf = TRUE)
|
|
|
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_ANNOTATION(const ENTITY* e)
|
|
|
logical is_ATTRIB_ST(const ENTITY* ent)
|
|
|
int is_ATTRIB_ST(const ENTITY*)
|
|
|
logical is_ATTRIB_SYS(const ENTITY* e)
|
|
|
logical is_ATTRIB_TAG(const ENTITY* e)
|
|
|
logical is_ATTRIB_TSL(const ENTITY* e)
|
|
|
logical is_BODY(const ENTITY* ent)
|
|
|
logical is_circular_edge(const ENTITY* ent)
|
|
|
logical is_closed_curve(EDGE* crv)
|
|
|
logical is_COEDGE(const ENTITY* ent)
|
|
|
logical is_CONE(const ENTITY* ent)
|
|
|
logical is_cone(const surface* surf)
|
|
|
logical is_conical_face(const ENTITY* ent)
|
|
|
logical is_CURVE(const ENTITY* ent)
|
|
|
logical is_curve_edge(const ENTITY* ent)
|
|
|
logical is_cylindrical_face(const ENTITY* ent)
|
|
|
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)
|
|
|
logical is_ENTITY(const ENTITY*)
|
|
|
logical is_FACE(const ENTITY* ent)
|
|
|
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_linear_edge(const ENTITY* ent)
|
|
|
logical is_LOOP(const ENTITY* ent)
|
|
|
logical is_LUMP(const ENTITY* ent)
|
|
|
logical is_PCURVE(const ENTITY* ent)
|
|
|
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_planar_wire(WIRE* this_wire, SPAposition& centroid, SPAunit_vector& normal, logical apply_transf = TRUE)
|
|
|
logical is_PLANE(const ENTITY* ent)
|
|
|
logical is_plane(const surface* surf)
|
|
|
logical is_Scm_Entity(ScmObject e)
|
|
|
logical is_Scm_Entity(ScmObject o, const entity_filter& filt)
|
|
|
logical is_Scm_Entity(ScmObject o, entity_test_proc test)
|
|
|
logical is_Scm_Entray(ScmObject r)
|
|
|
logical is_SHELL(const ENTITY* ent)
|
|
|
logical is_solid_body(const ENTITY* ent)
|
|
|
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_TCOEDGE(const ENTITY* e)
|
|
|
logical is_TEDGE(const ENTITY* e)
|
|
|
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_TVERTEX(const ENTITY* e)
|
|
|
logical is_UNDEFC(const ENTITY* e)
|
|
|
logical is_VERTEX(const ENTITY* ent)
|
|
|
logical is_WCS(const ENTITY* e)
|
|
|
logical is_WIRE(const ENTITY* ent)
|
|
|
logical is_wire_body(const ENTITY* ent)
|
|
|
ScmObject make_Scm_Entity(ENTITY* ent)
|
|
|
SURFACE* make_surface(surface const& this_surface)
|
|
|
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)
|
|
|
ENTITY* read_array(ENTITY* array[], const void* ptr)
|
|
|
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()
|
|
|
int read_int(const char*& test_string)
|
|
|
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)
|
|
|
int read_string(char* buf)
|
|
|
logical read_subtype_end()
|
|
|
logical read_subtype_start()
|
|
|
SPAtransf read_transf()
|
|
|
SPAunit_vector read_unit_vector()
|
|
|
SPAvector read_vector()
|
|
|
void reset_boxes(ENTITY* this_entity)
|
|
|
void reset_boxes_downward(ENTITY* ent)
|
|
|
curve* restore_curve()
|
|
|
void set_logging(logical onoff)
|
|
|
void sg_add_pcurves_to_entity(ENTITY* ent)
|
|
|
SPAposition to_model(const SPAposition& pt)
|
|
|
SPAunit_vector to_model(const SPAunit_vector& v)
|
|
|
SPAvector to_model(const SPAvector& v)
|
|
|
SPAposition to_wcs(const SPAposition& pt)
|
|
|
SPAunit_vector to_wcs(const SPAunit_vector& v)
|
|
|
SPAvector to_wcs(const SPAvector& v)
|
|
|
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()
|