int define_Computed_field_type_derivative_image_filter(struct Parse_state *state, void *field_modify_void, void *computed_field_simple_package_void) /******************************************************************************* LAST MODIFIED : 18 October 2006 DESCRIPTION : Converts <field> into type DERIVATIVE (if it is not already) and allows its contents to be modified. ==============================================================================*/ { int return_code; int order; int direction; 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_derivative_image_filter); USE_PARAMETER(computed_field_simple_package_void); if (state && (field_modify=(Computed_field_modify_data *)field_modify_void)) { return_code = 1; /* get valid parameters for projection field */ source_field = (struct Computed_field *)NULL; order = 1; direction=1; if ((NULL != field_modify->get_field()) && (computed_field_derivative_image_filter_type_string == Computed_field_get_type_string(field_modify->get_field()))) { return_code = Cmiss_field_get_type_derivative_image_filter(field_modify->get_field(), &source_field, &order, &direction); } if (return_code) { /* must access objects for set functions */ if (source_field) { ACCESS(Computed_field)(source_field); } option_table = CREATE(Option_table)(); Option_table_add_help(option_table, "The derivative_filter field uses the itk::DerivativeImageFilter code to calculate the derivative of a field in a particular direction. The <field> it operates on is usually a sample_texture field, based on a texture that has been created from image file(s). The <order> paramater sets the order of the derivative and the <direction> parameter is an integer value that specifies the direction to evaluate the derivative in. 0 corresponds to the x direction. See a/testing/image_processing_2D for an example of using this field. For more information see the itk software guide."); /* field */ set_source_field_data.computed_field_manager = field_modify->get_field_manager(); set_source_field_data.conditional_function = Computed_field_is_scalar; 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); /* order */ Option_table_add_int_non_negative_entry(option_table, "order", &order); /*direciton*/ Option_table_add_int_non_negative_entry(option_table, "direction", &direction); return_code = Option_table_multi_parse(option_table, state); DESTROY(Option_table)(&option_table); /* no errors,not asking for help */ if (return_code) { if (!source_field) { display_message(ERROR_MESSAGE, "define_Computed_field_type_derivative_image_filter. " "Missing source field"); return_code = 0; } } if (return_code) { return_code = field_modify->update_field_and_deaccess( Cmiss_field_module_create_derivative_image_filter( field_modify->get_field_module(), source_field, order, direction)); } 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_derivative_image_filter. Failed"); } } if (source_field) { DEACCESS(Computed_field)(&source_field); } } } else { display_message(ERROR_MESSAGE, "define_Computed_field_type_derivative_image_filter. Invalid argument(s)"); return_code = 0; } LEAVE; return (return_code); } /* define_Computed_field_type_derivative_image_filter */
int gfx_modify_spectrum_settings_log(struct Parse_state *state, void *modify_spectrum_data_void,void *spectrum_command_data_void) /******************************************************************************* LAST MODIFIED : 17 January 2001 DESCRIPTION : Executes a GFX MODIFY SPECTRUM LOG command. If return_code is 1, returns the completed Modify_spectrum_data with the parsed settings. Note that the settings are ACCESSed once on valid return. ==============================================================================*/ { char ambient,amb_diff,diffuse,emission,extend_above, extend_below,fix_maximum,fix_minimum,left,reverse,right, specular,transparent_above,transparent_below; enum Spectrum_settings_colour_mapping colour_mapping; int black_band_int,component,number_of_bands,range_components,return_code; float band_ratio,exaggeration,step_value; FE_value colour_range[2],range[2]; struct Modify_spectrum_data *modify_spectrum_data; struct Option_table *option_table, *render_option_table; struct Spectrum_settings *settings; ENTER(gfx_modify_spectrum_settings_log); USE_PARAMETER(spectrum_command_data_void); if (state) { modify_spectrum_data=(struct Modify_spectrum_data *)modify_spectrum_data_void; if (modify_spectrum_data) { /* create the spectrum_settings: */ settings=modify_spectrum_data->settings=CREATE(Spectrum_settings)(); if (settings) { /* access since deaccessed in gfx_modify_spectrum */ ACCESS(Spectrum_settings)(modify_spectrum_data->settings); Spectrum_settings_set_type(settings,SPECTRUM_LOG); colour_mapping = Spectrum_settings_get_colour_mapping(settings); ambient = 0; amb_diff = 0; band_ratio = 0.01; diffuse = 0; emission = 0; extend_above = 0; extend_below = 0; fix_maximum=0; fix_minimum=0; left = 0; number_of_bands = 10; reverse = 0; right = 0; specular = 0; step_value = 0.5; transparent_above = 0; transparent_below = 0; range_components = 2; colour_range[0] = 0.0; colour_range[1] = 1.0; range[0] = (FE_value)(modify_spectrum_data->spectrum_minimum); range[1] = (FE_value)(modify_spectrum_data->spectrum_maximum); component = Spectrum_settings_get_component_number(settings); exaggeration = Spectrum_settings_get_exaggeration(settings); option_table = CREATE(Option_table)(); /* band_ratio */ Option_table_add_float_entry(option_table, "band_ratio", &band_ratio); /* colour_range */ Option_table_add_FE_value_vector_entry(option_table, "colour_range", colour_range, &range_components); /* component */ Option_table_add_int_positive_entry(option_table, "component", &component); /* exaggeration */ Option_table_add_float_entry(option_table, "exaggeration", &exaggeration); /* extend_above */ Option_table_add_char_flag_entry(option_table, "extend_above", &extend_above); /* extend_below */ Option_table_add_char_flag_entry(option_table, "extend_below", &extend_below); /* fix_maximum */ Option_table_add_char_flag_entry(option_table, "fix_maximum", &fix_maximum); /* fix_minimum */ Option_table_add_char_flag_entry(option_table, "fix_minimum", &fix_minimum); /* left */ Option_table_add_char_flag_entry(option_table, "left", &left); /* number_of_bands */ Option_table_add_int_positive_entry(option_table, "number_of_bands", &number_of_bands); /* position */ Option_table_add_int_non_negative_entry(option_table, "position", &(modify_spectrum_data->position)); /* range */ Option_table_add_FE_value_vector_entry(option_table, "range", range, &range_components); /* reverse */ Option_table_add_char_flag_entry(option_table, "reverse", &reverse); /* right */ Option_table_add_char_flag_entry(option_table, "right", &right); /* step_value */ Option_table_add_float_entry(option_table, "step_value", &step_value); /* transparent_above */ Option_table_add_char_flag_entry(option_table, "transparent_above", &transparent_above); /* transparent_below */ Option_table_add_char_flag_entry(option_table, "transparent_below", &transparent_below); /* conversion_mode */ Option_table_add_enumerator_Spectrum_settings_colour_mapping( option_table, &colour_mapping); /* render_option */ render_option_table = CREATE(Option_table)(); Option_table_add_char_flag_entry(render_option_table, "ambient", &ambient); Option_table_add_char_flag_entry(render_option_table, "amb_diff", &amb_diff); Option_table_add_char_flag_entry(render_option_table, "diffuse", &diffuse); Option_table_add_char_flag_entry(render_option_table, "emission", &emission); Option_table_add_char_flag_entry(render_option_table, "specular", &specular); Option_table_add_suboption_table(option_table, render_option_table); if (!(return_code=Option_table_multi_parse(option_table,state))) { DEACCESS(Spectrum_settings)(&(modify_spectrum_data->settings)); } DESTROY(Option_table)(&option_table); if (return_code) { Spectrum_settings_set_colour_mapping(settings, colour_mapping); Spectrum_settings_set_number_of_bands(settings, number_of_bands); black_band_int = (band_ratio * 1000.0 + 0.5); Spectrum_settings_set_black_band_proportion(settings, black_band_int); Spectrum_settings_set_step_value(settings, step_value); } if ( return_code ) { if (specular + emission > 1) { display_message(ERROR_MESSAGE,"gfx_modify_spectrum_settings_linear. " "All spectrums are ambient diffuse. The specular and emission flags are ignored."); return_code=0; } } if ( return_code ) { if ( extend_above && transparent_above) { display_message(ERROR_MESSAGE,"gfx_modify_spectrum_settings_log. " "Specify only one of extend_above and transparent_above"); return_code=0; } else if (extend_above) { Spectrum_settings_set_extend_above_flag(settings, 1); } else if (transparent_above) { Spectrum_settings_set_extend_above_flag(settings, 0); } } if ( return_code ) { if ( extend_below && transparent_below) { display_message(ERROR_MESSAGE,"gfx_modify_spectrum_settings_log. " "Specify only one of extend_below and transparent_below"); return_code=0; } else if (extend_below) { Spectrum_settings_set_extend_below_flag(settings, 1); } else if (transparent_below) { Spectrum_settings_set_extend_below_flag(settings, 0); } } if ( return_code ) { if (left && right) { display_message(ERROR_MESSAGE,"gfx_modify_spectrum_settings_log. " "Specify only one of left or right"); return_code=0; } else if (left) { exaggeration = fabs(exaggeration); } else if (right) { exaggeration = -fabs(exaggeration); } Spectrum_settings_set_exaggeration(settings, exaggeration); } if ( return_code ) { Spectrum_settings_set_component_number(settings, component); Spectrum_settings_set_colour_value_minimum(settings, colour_range[0]); Spectrum_settings_set_colour_value_maximum(settings, colour_range[1]); Spectrum_settings_set_range_minimum(settings, range[0]); Spectrum_settings_set_range_maximum(settings, range[1]); Spectrum_settings_set_reverse_flag(settings, reverse); } /* Must set fix_maximum,fix_minimum after setting minimum and maximum range */ if ( return_code ) { if (fix_maximum) { Spectrum_settings_set_fix_maximum_flag(settings, 1); } } if ( return_code ) { if (fix_minimum) { Spectrum_settings_set_fix_minimum_flag(settings, 1); } } } else { display_message(ERROR_MESSAGE,"gfx_modify_spectrum_settings_log. " "Could not create settings"); return_code=0; } } else { display_message(ERROR_MESSAGE,"gfx_modify_spectrum_settings_log. " "No modify data"); return_code=0; } } else { display_message(ERROR_MESSAGE,"gfx_modify_spectrum_settings_log. Missing state"); return_code=0; } LEAVE; return (return_code); } /* gfx_modify_spectrum_log */
int define_Computed_field_type_binary_dilate_image_filter(struct Parse_state *state, void *field_modify_void, void *computed_field_simple_package_void) /******************************************************************************* LAST MODIFIED : 30 August 2006 DESCRIPTION : Converts <field> into type COMPUTED_FIELD_BINARYDILATEFILTER (if it is not already) and allows its contents to be modified. ==============================================================================*/ { int radius; double dilate_value; int return_code; 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_binary_dilate_image_filter); USE_PARAMETER(computed_field_simple_package_void); if (state && (field_modify=(Computed_field_modify_data *)field_modify_void)) { return_code = 1; /* get valid parameters for projection field */ source_field = (struct Computed_field *)NULL; radius = 1; dilate_value = 1; if ((NULL != field_modify->get_field()) && (computed_field_binary_dilate_image_filter_type_string == Computed_field_get_type_string(field_modify->get_field()))) { return_code = Cmiss_field_get_type_binary_dilate_image_filter(field_modify->get_field(), &source_field, &radius, &dilate_value); } if (return_code) { /* must access objects for set functions */ if (source_field) { ACCESS(Computed_field)(source_field); } option_table = CREATE(Option_table)(); Option_table_add_help(option_table, "The binary_dilate_filter field uses the itk::BinaryDilateImageFilter code to produce an output field which is a dilation of a binary image (an image where each pixel has 1 of 2 values). The region identified by the pixels with intensity <dilate_value> is dilate (enlarged), by replacing each pixel with a ball. The size of the ball is set by specifying the <radius>. The <field> it operates on is usually a thresholded or segmented field. See a/testing/image_processing_2D for an example of using this field. For more information see the itk software guide."); /* field */ set_source_field_data.computed_field_manager = field_modify->get_field_manager(); set_source_field_data.conditional_function = Computed_field_is_scalar; 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); /* radius */ Option_table_add_int_non_negative_entry(option_table, "radius", &radius); /* dilate_value */ Option_table_add_double_entry(option_table, "dilate_value", &dilate_value); return_code = Option_table_multi_parse(option_table, state); DESTROY(Option_table)(&option_table); /* no errors,not asking for help */ if (return_code) { if (!source_field) { display_message(ERROR_MESSAGE, "define_Computed_field_type_binary_dilate_image_filter. " "Missing source field"); return_code = 0; } } if (return_code) { return_code = field_modify->update_field_and_deaccess( Cmiss_field_module_create_binary_dilate_image_filter( field_modify->get_field_module(), source_field, radius, dilate_value)); } 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_binary_dilate_image_filter. Failed"); } } if (source_field) { DEACCESS(Computed_field)(&source_field); } } } else { display_message(ERROR_MESSAGE, "define_Computed_field_type_binary_dilate_image_filter. Invalid argument(s)"); return_code = 0; } LEAVE; return (return_code); } /* define_Computed_field_type_binary_dilate_image_filter */
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_curvature_anisotropic_diffusion_image_filter(struct Parse_state *state, void *field_modify_void, void *computed_field_simple_package_void) /******************************************************************************* LAST MODIFIED : 18 October 2006 DESCRIPTION : Converts <field> into type DISCRETEGAUSSIAN (if it is not already) and allows its contents to be modified. ==============================================================================*/ { int return_code; double timeStep; double conductance; int numIterations; 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_curvature_anisotropic_diffusion_image_filter); USE_PARAMETER(computed_field_simple_package_void); if (state && (field_modify=(Computed_field_modify_data *)field_modify_void)) { return_code = 1; /* get valid parameters for projection field */ source_field = (struct Computed_field *)NULL; timeStep = 0.125; conductance=3.0; numIterations = 5; if ((NULL != field_modify->get_field()) && (computed_field_curvature_anisotropic_diffusion_image_filter_type_string == Computed_field_get_type_string(field_modify->get_field()))) { return_code = Cmiss_field_get_type_curvature_anisotropic_diffusion_image_filter(field_modify->get_field(), &source_field, &timeStep, &conductance, &numIterations); } if (return_code) { /* must access objects for set functions */ if (source_field) { ACCESS(Computed_field)(source_field); } option_table = CREATE(Option_table)(); Option_table_add_help(option_table, "The curvature_anisotropic_filter field uses the itk::CurvatureAnisotropicImageFilter code to smooth a field to reduce noise (or unwanted detail) while preserving edges. The <field> it operates on is usually a sample_texture field, based on a texture that has been created from image file(s). The smoothing is accomplished by numerically solving a modified curvature diffusion equation. The accuracy of the numerical solution can be adjusted by varying the <time_step> and <num_iterations> used. The <conductance> is a parameter used by the diffusion equation. A high value of conductance causes the image to diffuse (smooth) more, while a low value puts more emphasis on preserving features. Typical conductance values are often in the range 0.5 to 2. See a/testing/image_processing_2D for an example of using this field. For more information see the itk software guide."); /* field */ set_source_field_data.computed_field_manager = field_modify->get_field_manager(); set_source_field_data.conditional_function = Computed_field_is_scalar; 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); /* timeStep */ Option_table_add_double_entry(option_table, "time_step", &timeStep); /* conductance */ Option_table_add_double_entry(option_table, "conductance", &conductance); /* numIterations */ Option_table_add_int_non_negative_entry(option_table, "num_iterations", (int*) &numIterations); return_code = Option_table_multi_parse(option_table, state); DESTROY(Option_table)(&option_table); /* no errors,not asking for help */ if (return_code) { if (!source_field) { display_message(ERROR_MESSAGE, "define_Computed_field_type_curvature_anisotropic_diffusion_image_filter. " "Missing source field"); return_code = 0; } } if (return_code) { return_code = field_modify->update_field_and_deaccess( Cmiss_field_module_create_curvature_anisotropic_diffusion_image_filter( field_modify->get_field_module(), source_field, timeStep, conductance, numIterations)); } 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_curvature_anisotropic_diffusion_image_filter. Failed"); } } if (source_field) { DEACCESS(Computed_field)(&source_field); } } } else { display_message(ERROR_MESSAGE, "define_Computed_field_type_curvature_anisotropic_diffusion_image_filter. Invalid argument(s)"); return_code = 0; } LEAVE; return (return_code); } /* define_Computed_field_type_curvature_anisotropic_diffusion_image_filter */