/** * Executes a GFX DEFINE GLYPH command. */ int gfx_define_glyph(struct Parse_state *state, void *glyph_name_void, void *define_glyph_data_void) { int return_code = 1; Define_glyph_data *define_glyph_data = static_cast<Define_glyph_data *>(define_glyph_data_void); if ((state) && (define_glyph_data)) { if (state->current_token) { const char *glyph_name = static_cast<char *>(glyph_name_void); bool process = false; if (glyph_name) { process = true; } else { if (Parse_state_help_mode(state)) { glyph_name = "GLYPH_NAME"; Option_table *option_table = CREATE(Option_table)(); Option_table_add_entry(option_table, "GLYPH_NAME", (void *)glyph_name, define_glyph_data_void, gfx_define_glyph); return_code = Option_table_parse(option_table, state); DESTROY(Option_table)(&option_table); } else { glyph_name = state->current_token; shift_Parse_state(state, 1); process = true; } } if (process) { char *scene_path_name = 0; struct Option_table *option_table = CREATE(Option_table)(); Option_table_add_help(option_table, "The 'scene' option defines a static glyph from the named graphics " "at the region/scene path."); /* scene (graphics) */ Option_table_add_string_entry(option_table, "scene", &scene_path_name, " [/REGION_PATH.]GRAPHICS_NAME"); return_code = Option_table_multi_parse(option_table, state); if (return_code) { cmzn_graphics* graphics = 0; const char *scene_name = 0; const char *graphics_name = 0; if (scene_path_name) export_object_name_parser(scene_path_name, &scene_name, &graphics_name); cmzn_region *input_region = cmzn_region_find_subregion_at_path(define_glyph_data->root_region, scene_name); if (input_region && graphics_name) { cmzn_scene_id scene = cmzn_region_get_scene(input_region); graphics = cmzn_scene_find_graphics_by_name(scene, graphics_name); cmzn_scene_destroy(&scene); } if (!graphics) { display_message(ERROR_MESSAGE, "gfx_define_glyph. Invalid scene region path or graphics name"); return_code = 0; } else { cmzn_glyphmodule_begin_change(define_glyph_data->glyphmodule); cmzn_glyph_id glyph = cmzn_glyphmodule_find_glyph_by_name(define_glyph_data->glyphmodule, glyph_name); if (glyph) { struct GT_object *graphics_object = cmzn_graphics_copy_graphics_object( graphics); if (!cmzn_glyph_set_graphics_object(glyph, graphics_object)) { display_message(ERROR_MESSAGE, "gfx_define_glyph. Unable to change glyph"); return_code = 0; } DEACCESS(GT_object)(&graphics_object); } else { glyph = cmzn_glyphmodule_create_static_glyph_from_graphics(define_glyph_data->glyphmodule, graphics); if ((CMZN_OK != cmzn_glyph_set_name(glyph, glyph_name)) || (CMZN_OK != cmzn_glyph_set_managed(glyph, true))) { display_message(ERROR_MESSAGE, "gfx_define_glyph. Failed"); return_code = 0; } } cmzn_glyph_destroy(&glyph); cmzn_glyphmodule_end_change(define_glyph_data->glyphmodule); } cmzn_graphics_destroy(&graphics); cmzn_region_destroy(&input_region); if (scene_name) DEALLOCATE(scene_name); if (graphics_name) DEALLOCATE(graphics_name); } if (scene_path_name) DEALLOCATE(scene_path_name); DESTROY(Option_table)(&option_table); } } else { display_message(ERROR_MESSAGE, "Missing glyph name"); display_parse_state_location(state); return_code=0; } } else { display_message(ERROR_MESSAGE, "gfx_define_glyph. Invalid argument(s)"); return_code = 0; } return (return_code); }
int define_Computed_field_type_compose(struct Parse_state *state, void *field_modify_void, void *computed_field_compose_package_void) /******************************************************************************* LAST MODIFIED : 24 August 2006 DESCRIPTION : Converts <field> into type COMPUTED_FIELD_COMPOSE (if it is not already) and allows its contents to be modified. ==============================================================================*/ { int return_code; Computed_field_compose_package *computed_field_compose_package; Computed_field_modify_data *field_modify; struct Option_table *find_option_table, *option_table, *out_of_bounds_option_table; struct Set_Computed_field_conditional_data set_calculate_values_field_data, set_find_element_xi_field_data, set_texture_coordinates_field_data; ENTER(define_Computed_field_type_compose); if (state && (field_modify=(Computed_field_modify_data *)field_modify_void) && (computed_field_compose_package = (Computed_field_compose_package *) computed_field_compose_package_void)) { return_code = 1; Cmiss_mesh_id mesh = 0; char *search_group_name = 0; Cmiss_field_id calculate_values_field = 0; Cmiss_field_id find_element_xi_field = 0; Cmiss_field_id texture_coordinates_field = 0; char find_nearest_flag = 0; char find_exact_flag = 0; char use_point_five_when_out_of_bounds_flag = 0; char fail_when_out_of_bounds_flag = 0; int use_point_five_when_out_of_bounds = 0; int element_dimension = 0; /* Maintain the existing behaviour as the default */ int find_nearest = 0; /* get valid parameters for composite field */ if (field_modify->get_field()) { Computed_field_compose* compose_core = dynamic_cast<Computed_field_compose*>(field_modify->get_field()->core); if (compose_core) { return_code = compose_core->get_type( &calculate_values_field, &find_element_xi_field, &texture_coordinates_field, &mesh, &find_nearest, &use_point_five_when_out_of_bounds); if (mesh) { Cmiss_mesh_access(mesh); element_dimension = Cmiss_mesh_get_dimension(mesh); } } } if (return_code) { /* must access objects for set functions */ if (calculate_values_field) { ACCESS(Computed_field)(calculate_values_field); } if (find_element_xi_field) { ACCESS(Computed_field)(find_element_xi_field); } if (texture_coordinates_field) { ACCESS(Computed_field)(texture_coordinates_field); } option_table = CREATE(Option_table)(); Option_table_add_help(option_table, "The value of a compose field is found by evaluating the <texture_coordinates_field>, " "then searching for matching values of the <find_element_xi_field> in the elements of " "the <mesh> (alternatively specified by <group> and <element_dimension>) and then " "finally evaluating the <calculate_values_field> at this found location. You can " "specify the outcome if the matching values cannot be found in the mesh with " "<use_point_five_when_out_of_bounds> or <fail_when_out_of_bounds>. See examples " "a/resample_texture or a/create_slices where the compose field is used to find the " "equivalent coordinate in another element to evaluate a texture."); /* calculate_values_field */ set_calculate_values_field_data.computed_field_manager = field_modify->get_field_manager(); set_calculate_values_field_data.conditional_function = Computed_field_has_numerical_components; set_calculate_values_field_data.conditional_function_user_data = (void *)NULL; Option_table_add_entry(option_table, "calculate_values_field", &calculate_values_field, &set_calculate_values_field_data, set_Computed_field_conditional); Option_table_add_int_positive_entry(option_table,"element_dimension", &element_dimension); /* find_element_xi_field */ set_find_element_xi_field_data.computed_field_manager = field_modify->get_field_manager(); set_find_element_xi_field_data.conditional_function = Computed_field_has_numerical_components; set_find_element_xi_field_data.conditional_function_user_data = (void *)NULL; Option_table_add_entry(option_table, "find_element_xi_field", &find_element_xi_field, &set_find_element_xi_field_data, set_Computed_field_conditional); find_option_table=CREATE(Option_table)(); Option_table_add_char_flag_entry(find_option_table,"find_nearest", &find_nearest_flag); Option_table_add_char_flag_entry(find_option_table,"find_exact", &find_exact_flag); Option_table_add_suboption_table(option_table, find_option_table); /* group */ Option_table_add_string_entry(option_table, "group", &search_group_name, " GROUP_NAME"); // mesh Option_table_add_mesh_entry(option_table, "mesh", field_modify->get_region(), &mesh); /* texture_coordinates_field */ set_texture_coordinates_field_data.computed_field_manager = field_modify->get_field_manager(); set_texture_coordinates_field_data.conditional_function = Computed_field_has_numerical_components; set_texture_coordinates_field_data.conditional_function_user_data = (void *)NULL; Option_table_add_entry(option_table, "texture_coordinates_field", &texture_coordinates_field, &set_texture_coordinates_field_data, set_Computed_field_conditional); out_of_bounds_option_table=CREATE(Option_table)(); /* use_point_five_when_out_of_bounds */ Option_table_add_char_flag_entry(out_of_bounds_option_table, "use_point_five_when_out_of_bounds", &use_point_five_when_out_of_bounds_flag); Option_table_add_char_flag_entry(out_of_bounds_option_table, "fail_when_out_of_bounds", &fail_when_out_of_bounds_flag); Option_table_add_suboption_table(option_table, out_of_bounds_option_table); return_code = Option_table_multi_parse(option_table, state); if (return_code && !mesh) { mesh = Cmiss_field_module_find_mesh_by_dimension( field_modify->get_field_module(), element_dimension); if (search_group_name) { Cmiss_field_id group_field = Cmiss_field_module_find_field_by_name(field_modify->get_field_module(), search_group_name); Cmiss_field_group_id group = Cmiss_field_cast_group(group_field); Cmiss_field_element_group_id element_group = Cmiss_field_group_get_element_group(group, mesh); Cmiss_mesh_destroy(&mesh); mesh = Cmiss_mesh_group_base_cast(Cmiss_field_element_group_get_mesh(element_group)); Cmiss_field_element_group_destroy(&element_group); Cmiss_field_group_destroy(&group); Cmiss_field_destroy(&group_field); } } if (return_code && !mesh) { display_message(ERROR_MESSAGE, "You must specify a mesh (or element_dimension and optional group)."); return_code = 0; } if (return_code) { if (find_nearest_flag && find_exact_flag) { display_message(ERROR_MESSAGE, "Specify only one of find_nearest and find_exact"); return_code = 0; } if (find_nearest_flag) { find_nearest = 1; } else if (find_exact_flag) { find_nearest = 0; } if (use_point_five_when_out_of_bounds_flag && fail_when_out_of_bounds_flag) { display_message(ERROR_MESSAGE, "Specify only one of use_point_five_when_out_of_bounds " "and fail_when_out_of_bounds"); return_code = 0; } if (use_point_five_when_out_of_bounds_flag) { use_point_five_when_out_of_bounds = 1; } else if (fail_when_out_of_bounds_flag) { use_point_five_when_out_of_bounds = 0; } } if (return_code) { return_code = field_modify->update_field_and_deaccess( Computed_field_create_compose(field_modify->get_field_module(), texture_coordinates_field, find_element_xi_field, calculate_values_field, mesh, find_nearest, use_point_five_when_out_of_bounds)); } if (!return_code) { if ((!state->current_token) || (strcmp(PARSER_HELP_STRING, state->current_token)&& strcmp(PARSER_RECURSIVE_HELP_STRING, state->current_token))) { /* error */ display_message(ERROR_MESSAGE, "define_Computed_field_type_compose. Failed"); } } Cmiss_mesh_destroy(&mesh); if (calculate_values_field) { DEACCESS(Computed_field)(&calculate_values_field); } if (find_element_xi_field) { DEACCESS(Computed_field)(&find_element_xi_field); } if (search_group_name) { DEALLOCATE(search_group_name); } if (texture_coordinates_field) { DEACCESS(Computed_field)(&texture_coordinates_field); } DESTROY(Option_table)(&option_table); } } else { display_message(ERROR_MESSAGE, "define_Computed_field_type_compose. Invalid argument(s)"); return_code = 0; } LEAVE; return (return_code); } /* define_Computed_field_type_compose */
int gfx_define_font(struct Parse_state *state, void *dummy_to_be_modified,void *graphics_module_void) /******************************************************************************* LAST MODIFIED : 12 March 2008 DESCRIPTION : Executes a GFX DEFINE FONT command. ==============================================================================*/ { const char *current_token, *font_name; int return_code; Cmiss_graphics_module_id graphics_module = 0; if (state && (graphics_module = (Cmiss_graphics_module_id)graphics_module_void)) { if (NULL != (current_token = state->current_token)) { if (strcmp(PARSER_HELP_STRING,current_token)&& strcmp(PARSER_RECURSIVE_HELP_STRING,current_token)) { font_name = current_token; if (shift_Parse_state(state,1)&& (current_token=state->current_token)) { Cmiss_graphics_font_id font = Cmiss_graphics_module_find_font_by_name( graphics_module, font_name); if (!font) { font = Cmiss_graphics_module_create_font(graphics_module); Cmiss_graphics_font_set_name(font, font_name); } Cmiss_graphics_font_type font_type = Cmiss_graphics_font_get_type(font); Cmiss_graphics_font_true_type true_type = Cmiss_graphics_font_get_true_type(font); char *font_type_string = 0; char *true_type_string = 0; int number_of_valid_strings_font_type = 0; int number_of_valid_strings_true_type = 0; const char **valid_font_type_strings = ENUMERATOR_GET_VALID_STRINGS(Cmiss_graphics_font_type)( &number_of_valid_strings_font_type, (ENUMERATOR_CONDITIONAL_FUNCTION(Cmiss_graphics_font_type) *)NULL, (void *)NULL); std::string all_font_types = " "; for (int i = 0; i < number_of_valid_strings_font_type; i++) { if (i) all_font_types += "|"; all_font_types += valid_font_type_strings[i]; } const char *all_font_types_help = all_font_types.c_str(); const char **valid_font_true_type_strings = ENUMERATOR_GET_VALID_STRINGS(Cmiss_graphics_font_true_type)( &number_of_valid_strings_true_type, (ENUMERATOR_CONDITIONAL_FUNCTION(Cmiss_graphics_font_true_type) *)NULL, (void *)NULL); std::string all_font_true_types = " "; for (int i = 0; i < number_of_valid_strings_true_type; i++) { if (i) all_font_true_types += "|"; all_font_true_types += valid_font_true_type_strings[i]; } const char *all_font_true_types_help = all_font_true_types.c_str(); struct Option_table *option_table = CREATE(Option_table)(); int bold_flag = 0; int italic_flag = 0; float depth = (float)Cmiss_graphics_font_get_depth(font); int size = Cmiss_graphics_font_get_size(font); /* bold */ Option_table_add_entry(option_table, "bold", (void *)&bold_flag, NULL, set_char_flag); Option_table_add_entry(option_table, "italic", (void *)&italic_flag, NULL, set_char_flag); Option_table_add_entry(option_table,"depth", &(depth),NULL,set_float); Option_table_add_entry(option_table,"size", &(size),NULL,set_int_non_negative); Option_table_add_string_entry(option_table, "font_type", &font_type_string, all_font_types_help); Option_table_add_string_entry(option_table, "true_type", &true_type_string, all_font_true_types_help); return_code = Option_table_multi_parse(option_table, state); if (return_code) { if (font_type_string) { STRING_TO_ENUMERATOR(Cmiss_graphics_font_type)(font_type_string, &font_type); if (CMISS_GRAPHICS_FONT_TYPE_INVALID == font_type) { display_message(ERROR_MESSAGE, "gfx_define_font: Invalid font type %s", font_type_string); return_code = 0; } } else { display_message(ERROR_MESSAGE, "gfx_define_font: Missing font_type argument"); return_code = 0; } if (true_type_string) { STRING_TO_ENUMERATOR(Cmiss_graphics_font_true_type)(true_type_string, &true_type); if (CMISS_GRAPHICS_FONT_TRUE_TYPE_INVALID == true_type) { display_message(ERROR_MESSAGE, "gfx_define_font: Invalid true type %s", true_type_string); return_code = 0; } } else { display_message(ERROR_MESSAGE, "gfx_define_font: Missing true_type argument"); return_code = 0; } if (font) { Cmiss_graphics_font_set_bold(font, bold_flag); Cmiss_graphics_font_set_italic(font, italic_flag); Cmiss_graphics_font_set_depth(font, depth); Cmiss_graphics_font_set_size(font, size); Cmiss_graphics_font_set_true_type(font, true_type); Cmiss_graphics_font_set_type(font, font_type); } } Cmiss_graphics_font_destroy(&font); DEALLOCATE(font_type_string); DEALLOCATE(true_type_string); DESTROY(Option_table)(&option_table); } else { display_message(WARNING_MESSAGE,"Missing font string."); display_parse_state_location(state); return_code=0; } }
int define_Computed_field_type_nodal_lookup(struct Parse_state *state, void *field_modify_void, void *computed_field_lookup_package_void) /******************************************************************************* LAST MODIFIED : 25 August 2006 DESCRIPTION : Converts <field> into type COMPUTED_FIELD_NODAL_LOOKUP (if it is not already) and allows its contents to be modified. ==============================================================================*/ { int return_code; Computed_field_lookup_package *computed_field_lookup_package; Computed_field_modify_data *field_modify; if (state&&(field_modify=(Computed_field_modify_data *)field_modify_void) && (computed_field_lookup_package= (Computed_field_lookup_package *) computed_field_lookup_package_void)) { return_code = 1; Cmiss_field_id source_field = 0; char *nodeset_name = duplicate_string("cmiss_nodes"); char node_flag = 0; int node_identifier = 0; if ((NULL != field_modify->get_field()) && (computed_field_nodal_lookup_type_string == Computed_field_get_type_string(field_modify->get_field()))) { Cmiss_node_id lookup_node = 0; return_code = Computed_field_get_type_nodal_lookup(field_modify->get_field(), &source_field, &lookup_node); if (source_field) { ACCESS(Computed_field)(source_field); } if (lookup_node) { node_identifier = get_FE_node_identifier(lookup_node); FE_region *fe_region = FE_node_get_FE_region(lookup_node); if (!FE_region_contains_FE_node(fe_region, lookup_node)) { DEALLOCATE(nodeset_name); nodeset_name = duplicate_string("cmiss_data"); } node_flag = 1; } } Option_table *option_table = CREATE(Option_table)(); /* source field */ Set_Computed_field_conditional_data set_source_field_data; set_source_field_data.computed_field_manager = field_modify->get_field_manager(); set_source_field_data.conditional_function = Computed_field_has_numerical_components; set_source_field_data.conditional_function_user_data = (void *)NULL; Option_table_add_entry(option_table,"field", &source_field, &set_source_field_data,set_Computed_field_conditional); /* the node to nodal_lookup */ Option_table_add_entry(option_table, "node", &node_identifier, &node_flag, set_int_and_char_flag); /* the nodeset the node is from */ Option_table_add_string_entry(option_table, "nodeset", &nodeset_name, " NODE_GROUP_FIELD_NAME|[GROUP_NAME.]cmiss_nodes|cmiss_data[cmiss_nodes]"); return_code = Option_table_multi_parse(option_table,state); DESTROY(Option_table)(&option_table); if (return_code && node_flag) { Cmiss_nodeset_id nodeset = Cmiss_field_module_find_nodeset_by_name(field_modify->get_field_module(), nodeset_name); Cmiss_node_id node = Cmiss_nodeset_find_node_by_identifier(nodeset, node_identifier); if (node) { return_code = field_modify->update_field_and_deaccess( Computed_field_create_nodal_lookup(field_modify->get_field_module(), source_field, node)); } else { display_message(ERROR_MESSAGE, "define field nodal lookup. Invalid node %d", node_identifier); return_code = 0; } Cmiss_node_destroy(&node); Cmiss_nodeset_destroy(&nodeset); } else { if ((!state->current_token)|| (strcmp(PARSER_HELP_STRING,state->current_token)&& strcmp(PARSER_RECURSIVE_HELP_STRING,state->current_token))) { display_message(ERROR_MESSAGE, "define_Computed_field_type_time_nodal_lookup. Failed"); } } DEALLOCATE(nodeset_name); REACCESS(Computed_field)(&source_field, NULL); } else { display_message(ERROR_MESSAGE, "define_Computed_field_type_nodal_lookup. Invalid argument(s)"); return_code = 0; } return (return_code); }
int define_Computed_field_type_quaternion_SLERP(struct Parse_state *state, void *field_modify_void, void *computed_field_lookup_package_void) /******************************************************************************* LAST MODIFIED : 25 August 2006 DESCRIPTION : Converts <field> into type 'quaterions' (if it is not already) and allows its contents to be modified. ==============================================================================*/ { int return_code; Computed_field_lookup_package *computed_field_lookup_package; Computed_field_modify_data *field_modify; ENTER(define_Computed_field_type_quaternion_SLERP); if (state&&(field_modify=(Computed_field_modify_data *)field_modify_void) && (computed_field_lookup_package= (Computed_field_lookup_package *) computed_field_lookup_package_void)) { return_code = 1; Cmiss_field_id source_field = 0; char *nodeset_name = duplicate_string("cmiss_nodes"); char node_flag = 0; int node_identifier = 0; if ((NULL != field_modify->get_field()) && (computed_field_quaternion_SLERP_type_string == Computed_field_get_type_string(field_modify->get_field()))) { Cmiss_node_id lookup_node = 0; return_code = Computed_field_get_type_quaternion_SLERP(field_modify->get_field(), &source_field, &lookup_node); if (source_field) { ACCESS(Computed_field)(source_field); } if (lookup_node) { node_identifier = get_FE_node_identifier(lookup_node); FE_region *fe_region = FE_node_get_FE_region(lookup_node); if (!FE_region_contains_FE_node(fe_region, lookup_node)) { DEALLOCATE(nodeset_name); nodeset_name = duplicate_string("cmiss_data"); } node_flag = 1; } } Option_table *option_table = CREATE(Option_table)(); Option_table_add_help(option_table, "A 4 components quaternion field. The components of " "the quaternion field are expected to be the w, x, y, z components" "of a quaternion (4 components in total). The quaternion field is" "evaluated and interpolated using SLERP at a normalised time between two" "quaternions (read in from the exnode generally). This quaternion field" "can be convert to a matrix with quaternion_to_matrix field, the resulting" "matrix can be used to create a smooth time dependent rotation for an object" "using the quaternion_to_matrix field. This field must be define directly from" "exnode file or from a matrix_to_quaternion field"); Set_Computed_field_conditional_data set_source_field_data; set_source_field_data.computed_field_manager = field_modify->get_field_manager(); set_source_field_data.conditional_function = Computed_field_has_4_components; set_source_field_data.conditional_function_user_data = (void *)NULL; Option_table_add_entry(option_table, "field", &source_field, &set_source_field_data, set_Computed_field_conditional); /* identifier of the node to lookup */ Option_table_add_entry(option_table, "node", &node_identifier, &node_flag, set_int_and_char_flag); /* the nodeset the node is from */ Option_table_add_string_entry(option_table, "nodeset", &nodeset_name, " NODE_GROUP_FIELD_NAME|[GROUP_NAME.]cmiss_nodes|cmiss_data[cmiss_nodes]"); return_code = Option_table_multi_parse(option_table, state); DESTROY(Option_table)(&option_table); if (return_code && node_flag) { Cmiss_nodeset_id nodeset = Cmiss_field_module_find_nodeset_by_name(field_modify->get_field_module(), nodeset_name); Cmiss_node_id node = Cmiss_nodeset_find_node_by_identifier(nodeset, node_identifier); if (node) { return_code = field_modify->update_field_and_deaccess( Computed_field_create_quaternion_SLERP(field_modify->get_field_module(), source_field, node)); } else { display_message(ERROR_MESSAGE, "define field quaternion_SLERP. Invalid node %d", node_identifier); return_code = 0; } Cmiss_node_destroy(&node); Cmiss_nodeset_destroy(&nodeset); } else { if ((!state->current_token)|| (strcmp(PARSER_HELP_STRING,state->current_token)&& strcmp(PARSER_RECURSIVE_HELP_STRING,state->current_token))) { display_message(ERROR_MESSAGE, "define_Computed_field_type_quaternion_SLERP. Failed"); } } DEALLOCATE(nodeset_name); REACCESS(Computed_field)(&source_field, NULL); } else { display_message(ERROR_MESSAGE, "define_Computed_field_type_quaternion_SLERP. Invalid argument(s)"); return_code = 0; } LEAVE; return (return_code); } /* define_Computed_field_type_quaternion_SLERP */
int define_Computed_field_type_integration(Parse_state *state, void *field_modify_void,void *computed_field_integration_package_void) /******************************************************************************* LAST MODIFIED : 24 August 2006 DESCRIPTION : Converts <field> into type COMPUTED_FIELD_INTEGRATION (if it is not already) and allows its contents to be modified. ==============================================================================*/ { int return_code = 1; ENTER(define_Computed_field_type_integration); Computed_field_modify_data *field_modify = reinterpret_cast<Computed_field_modify_data *>(field_modify_void); USE_PARAMETER(computed_field_integration_package_void); if (state && field_modify) { cmzn_region_id region = field_modify->get_region(); cmzn_mesh_id mesh = 0; cmzn_field_id coordinate_field = 0; cmzn_field_id integrand = 0; int magnitude_coordinates_flag = 0; int seed_element_identifier = 0; float time_update = 0; if ((NULL != field_modify->get_field()) && Computed_field_is_type_integration(field_modify->get_field())) { cmzn_element_id seed_element; return_code = Computed_field_get_type_integration(field_modify->get_field(), &mesh, &seed_element, &integrand, &magnitude_coordinates_flag, &coordinate_field); if (seed_element) { seed_element_identifier = cmzn_element_get_identifier(seed_element); cmzn_element_destroy(&seed_element); } } if (coordinate_field) { ACCESS(Computed_field)(coordinate_field); } if (integrand) { ACCESS(Computed_field)(integrand); } else { /* Make a default integrand of one */ double value = 1.0; // use temporary field module to supply different defaults cmzn_fieldmodule *temp_field_module = cmzn_region_get_fieldmodule(region); cmzn_fieldmodule_set_field_name(temp_field_module, "constant_1.0"); integrand = Computed_field_create_constant(temp_field_module, /*number_of_components*/1, &value); if (NULL == integrand) { display_message(ERROR_MESSAGE, "define_Computed_field_type_integration. Unable to create constant integrand"); return_code = 0; } cmzn_fieldmodule_destroy(&temp_field_module); } char *group_name = 0; Option_table *option_table = CREATE(Option_table)(); /* coordinate */ Set_Computed_field_conditional_data set_coordinate_field_data; set_coordinate_field_data.computed_field_manager = field_modify->get_field_manager(); set_coordinate_field_data.conditional_function = Computed_field_has_up_to_3_numerical_components; set_coordinate_field_data.conditional_function_user_data = 0; Option_table_add_Computed_field_conditional_entry(option_table, "coordinate", &coordinate_field, &set_coordinate_field_data); /* integrand */ Set_Computed_field_conditional_data set_integrand_field_data; set_integrand_field_data.computed_field_manager = field_modify->get_field_manager(); set_integrand_field_data.conditional_function = Computed_field_is_scalar; set_integrand_field_data.conditional_function_user_data = 0; Option_table_add_Computed_field_conditional_entry(option_table, "integrand", &integrand, &set_integrand_field_data); /* magnitude_coordinates|no_magnitude_coordinates */ Option_table_add_switch(option_table, "magnitude_coordinates", "no_magnitude_coordinates", &magnitude_coordinates_flag); // mesh Option_table_add_mesh_entry(option_table, "mesh", region, &mesh); /* region - legacy group name */ Option_table_add_string_entry(option_table, "region", &group_name, " GROUP_NAME(DEPRECATED)"); /* seed_element */ Option_table_add_int_non_negative_entry(option_table, "seed_element", &seed_element_identifier); /* update_time_integration */ Option_table_add_entry(option_table,"update_time_integration", &time_update, NULL, set_float); return_code = Option_table_multi_parse(option_table,state); DESTROY(Option_table)(&option_table); if (return_code && !mesh) { int dimension = FE_region_get_highest_dimension(cmzn_region_get_FE_region(region)); mesh = cmzn_fieldmodule_find_mesh_by_dimension(field_modify->get_field_module(), dimension); if (group_name) { cmzn_field_id group_field = cmzn_fieldmodule_find_field_by_name(field_modify->get_field_module(), group_name); cmzn_field_group_id group = cmzn_field_cast_group(group_field); cmzn_field_element_group_id element_group = cmzn_field_group_get_field_element_group(group, mesh); cmzn_mesh_destroy(&mesh); mesh = cmzn_mesh_group_base_cast(cmzn_field_element_group_get_mesh_group(element_group)); cmzn_field_element_group_destroy(&element_group); cmzn_field_group_destroy(&group); cmzn_field_destroy(&group_field); } } if (return_code && !mesh) { display_message(ERROR_MESSAGE, "You must specify a mesh."); return_code = 0; } if (return_code && !coordinate_field) { display_message(ERROR_MESSAGE, "You must specify a coordinate field."); return_code = 0; } if (return_code && !integrand) { display_message(ERROR_MESSAGE, "You must specify an integrand field."); return_code = 0; } cmzn_element_id seed_element = 0; if (return_code) { seed_element = cmzn_mesh_find_element_by_identifier(mesh, seed_element_identifier); if (!seed_element) { display_message(ERROR_MESSAGE, "Could not find seed_element %d in mesh.", seed_element_identifier); return_code = 0; } } if (return_code) { if (time_update && (NULL != field_modify->get_field()) && Computed_field_is_type_integration(field_modify->get_field())) { display_message(ERROR_MESSAGE, "The update_time_integration code has not been updated" "with the latest changes."); return_code=0; } else { return_code = field_modify->update_field_and_deaccess( Computed_field_create_integration(field_modify->get_field_module(), mesh, seed_element, integrand, magnitude_coordinates_flag, coordinate_field)); } } if (group_name) { DEALLOCATE(group_name); } cmzn_element_destroy(&seed_element); cmzn_mesh_destroy(&mesh); cmzn_field_destroy(&coordinate_field); cmzn_field_destroy(&integrand); } else { display_message(ERROR_MESSAGE, "define_Computed_field_type_integration. Invalid argument(s)"); return_code=0; } LEAVE; return (return_code); }
int define_Computed_field_type_xi_texture_coordinates(Parse_state *state, void *field_modify_void,void *computed_field_integration_package_void) /******************************************************************************* LAST MODIFIED : 24 August 2006 DESCRIPTION : Converts <field> into type COMPUTED_FIELD_XI_TEXTURE_COORDINATES (if it is not already) and allows its contents to be modified. ==============================================================================*/ { int return_code = 1; ENTER(define_Computed_field_type_xi_texture_coordinates); Computed_field_modify_data *field_modify = reinterpret_cast<Computed_field_modify_data *>(field_modify_void); USE_PARAMETER(computed_field_integration_package_void); if (state && field_modify) { cmzn_region_id region = field_modify->get_region(); cmzn_mesh_id mesh = 0; int seed_element_identifier = 0; char *group_name = 0; Option_table *option_table = CREATE(Option_table)(); // mesh Option_table_add_mesh_entry(option_table, "mesh", region, &mesh); /* region - legacy group name */ Option_table_add_string_entry(option_table, "region", &group_name, " GROUP_NAME(OBSOLETE)"); /* seed_element */ Option_table_add_int_non_negative_entry(option_table, "seed_element", &seed_element_identifier); return_code = Option_table_multi_parse(option_table,state); DESTROY(Option_table)(&option_table); if (return_code && !mesh) { int dimension = FE_region_get_highest_dimension(cmzn_region_get_FE_region(region)); mesh = cmzn_fieldmodule_find_mesh_by_dimension(field_modify->get_field_module(), dimension); if (group_name) { cmzn_field_id group_field = cmzn_fieldmodule_find_field_by_name(field_modify->get_field_module(), group_name); cmzn_field_group_id group = cmzn_field_cast_group(group_field); cmzn_field_element_group_id element_group = cmzn_field_group_get_field_element_group(group, mesh); cmzn_mesh_destroy(&mesh); mesh = cmzn_mesh_group_base_cast(cmzn_field_element_group_get_mesh_group(element_group)); cmzn_field_element_group_destroy(&element_group); cmzn_field_group_destroy(&group); cmzn_field_destroy(&group_field); } } if (return_code && !mesh) { display_message(ERROR_MESSAGE, "Must specify mesh."); return_code = 0; } cmzn_element_id seed_element = 0; if (return_code) { seed_element = cmzn_mesh_find_element_by_identifier(mesh, seed_element_identifier); if (!seed_element) { display_message(ERROR_MESSAGE, "Could not find seed_element %d in mesh.", seed_element_identifier); return_code = 0; } } // use temporary field module to supply different defaults cmzn_field_id coordinate_field = FIRST_OBJECT_IN_MANAGER_THAT(Computed_field)( Computed_field_is_type_xi_coordinates, (void *)NULL, field_modify->get_field_manager()); if (coordinate_field) { ACCESS(Computed_field)(coordinate_field); } else { if ((!state->current_token) || (strcmp(PARSER_HELP_STRING, state->current_token)&& strcmp(PARSER_RECURSIVE_HELP_STRING, state->current_token))) { display_message(ERROR_MESSAGE, "define_Computed_field_type_xi_texture_coordinates. xi field not found"); } return_code = 0; } double value = 1.0; cmzn_fieldmodule *temp_field_module = cmzn_region_get_fieldmodule(region); cmzn_fieldmodule_set_field_name(temp_field_module, "constant_1.0"); Computed_field *integrand = Computed_field_create_constant(temp_field_module, /*number_of_components*/1, &value); cmzn_fieldmodule_destroy(&temp_field_module); if (NULL == integrand) { display_message(ERROR_MESSAGE, "define_Computed_field_type_xi_texture_coordinates. Unable to create constant field"); return_code = 0; } if (return_code) { return_code = field_modify->update_field_and_deaccess( Computed_field_create_integration(field_modify->get_field_module(), mesh, seed_element, integrand, /*magnitude_coordinates*/0, coordinate_field)); } if (group_name) { DEALLOCATE(group_name); } cmzn_element_destroy(&seed_element); cmzn_mesh_destroy(&mesh); cmzn_field_destroy(&coordinate_field); cmzn_field_destroy(&integrand); } else { display_message(ERROR_MESSAGE, "define_Computed_field_type_xi_texture_coordinates. Invalid argument(s)"); return_code=0; } LEAVE; return (return_code); }
int define_Computed_field_type_format_output(struct Parse_state *state, void *field_modify_void,void *computed_field_arithmetic_operators_package_void) /******************************************************************************* LAST MODIFIED : 15 May 2008 DESCRIPTION : Converts <field> into type COMPUTED_FIELD_FORMAT_OUTPUT (if it is not already) and allows its contents to be modified. ==============================================================================*/ { int return_code; char *format_string; struct Computed_field *source_field; Computed_field_modify_data *field_modify; struct Option_table *option_table; struct Set_Computed_field_conditional_data set_source_field_data; ENTER(define_Computed_field_type_format_output); USE_PARAMETER(computed_field_arithmetic_operators_package_void); if (state&&(field_modify=(Computed_field_modify_data *)field_modify_void)) { return_code=1; source_field = (struct Computed_field *)NULL; format_string = NULL; if ((NULL != field_modify->get_field()) && (computed_field_format_output_type_string == Computed_field_get_type_string(field_modify->get_field()))) { return_code=Computed_field_get_type_format_output(field_modify->get_field(), &source_field, &format_string); } if (return_code) { /* must access objects for set functions */ if (source_field) { ACCESS(Computed_field)(source_field); } option_table = CREATE(Option_table)(); /* fields */ set_source_field_data.computed_field_manager= field_modify->get_field_manager(); set_source_field_data.conditional_function= Computed_field_has_numerical_components; set_source_field_data.conditional_function_user_data=(void *)NULL; Option_table_add_Computed_field_conditional_entry(option_table,"field", &source_field, &set_source_field_data); Option_table_add_string_entry(option_table, "format_string", &format_string, "C style formatting string"); return_code=Option_table_multi_parse(option_table,state); /* no errors,not asking for help */ if (return_code) { return_code = field_modify->update_field_and_deaccess( Computed_field_create_format_output(field_modify->get_field_module(), source_field, format_string)); } if (!return_code) { if ((!state->current_token)|| (strcmp(PARSER_HELP_STRING,state->current_token)&& strcmp(PARSER_RECURSIVE_HELP_STRING,state->current_token))) { /* error */ display_message(ERROR_MESSAGE, "define_Computed_field_type_format_output. Failed"); } } if (source_field) { DEACCESS(Computed_field)(&source_field); } if (format_string) DEALLOCATE(format_string); DESTROY(Option_table)(&option_table); } else { display_message(ERROR_MESSAGE, "define_Computed_field_type_format_output. Not enough memory"); return_code = 0; } } else { display_message(ERROR_MESSAGE, "define_Computed_field_type_format_output. Invalid argument(s)"); return_code = 0; } LEAVE; return (return_code); } /* define_Computed_field_type_format_output */