int set_Cmiss_region_or_group(struct Parse_state *state,
void *region_address_void, void *group_address_void)
{
Cmiss_region_id *region_address = reinterpret_cast<Cmiss_region_id*>(region_address_void);
Cmiss_field_group_id *group_address = reinterpret_cast<Cmiss_field_group_id*>(group_address_void);
if (!(state && region_address && *region_address && group_address && !*group_address))
return 0;
const char *current_token = state->current_token;
int return_code = 1;
if (!current_token)
{
display_message(WARNING_MESSAGE, "Missing region/group path");
display_parse_state_location(state);
return_code = 0;
}
else if (Parse_state_help_mode(state))
{
display_message(INFORMATION_MESSAGE, " REGION_PATH/GROUP");
}
else
{
char *region_path = 0;
char *field_name = 0;
Cmiss_region_id output_region = 0;
if (Cmiss_region_get_partial_region_path(*region_address, current_token,
&output_region, ®ion_path, &field_name) && output_region)
{
REACCESS(Cmiss_region)(region_address, output_region);
if (field_name)
{
Cmiss_field *field = FIND_BY_IDENTIFIER_IN_MANAGER(Computed_field,name)(
field_name, Cmiss_region_get_Computed_field_manager(output_region));
*group_address = Cmiss_field_cast_group(field);
if (0 == *group_address)
{
return_code = 0;
}
}
if (return_code)
{
shift_Parse_state(state, 1);
}
}
else
{
return_code = 0;
}
if (!return_code)
{
display_message(ERROR_MESSAGE, "Invalid region or group path: %s", current_token);
display_parse_state_location(state);
}
DEALLOCATE(region_path);
DEALLOCATE(field_name);
}
return return_code;
}
int set_Cmiss_region(struct Parse_state *state, void *region_address_void,
void *root_region_void)
{
const char *current_token;
int return_code;
struct Cmiss_region *region, **region_address, *root_region;
ENTER(set_Cmiss_region);
if (state && (root_region = static_cast<struct Cmiss_region *>(root_region_void)) &&
(region_address = static_cast<struct Cmiss_region **>(region_address_void)))
{
if ((current_token = state->current_token))
{
if (!Parse_state_help_mode(state))
{
region = Cmiss_region_find_subregion_at_path(root_region, current_token);
if (region)
{
//-- REACCESS(Cmiss_region)(region_address, region);
return_code = shift_Parse_state(state, 1);
}
else
{
display_message(ERROR_MESSAGE,
"set_Cmiss_region: Could not find subregion %s", current_token);
display_parse_state_location(state);
return_code = 0;
}
}
else
{
display_message(INFORMATION_MESSAGE," PATH_TO_REGION");
if (*region_address)
{
char *path = Cmiss_region_get_path(*region_address);
display_message(INFORMATION_MESSAGE, "[%s]", path);
DEALLOCATE(path);
}
return_code = 1;
}
}
else
{
display_message(ERROR_MESSAGE, "Missing region path");
display_parse_state_location(state);
return_code = 0;
}
}
else
{
display_message(ERROR_MESSAGE, "set_Cmiss_region. Missing state");
return_code = 0;
}
LEAVE;
return (return_code);
}
/***************************************************************************//**
* Modifier function to set the region, region path and field name.
* Fields must not be the same name as a child region.
*
* Examples:
* /heart/coordinates = region path and field name
* heart = region path only
* coordinates = field name only
* @param region_path_and_name a struct Cmiss_region_path_and_name which if
* set contains an ACCESSed region and allocated path and name which caller
* is required to clean up. Name may be NULL if path is fully resolved.
*/
static int set_region_path_and_or_field_name(struct Parse_state *state,
void *region_path_and_name_void, void *root_region_void)
{
const char *current_token;
int return_code;
struct Cmiss_region_path_and_name *name_data;
struct Cmiss_region *root_region;
ENTER(set_region_path_and_or_field_name);
if (state && (name_data = (struct Cmiss_region_path_and_name *)region_path_and_name_void) &&
(root_region = (struct Cmiss_region *)root_region_void))
{
current_token = state->current_token;
if (!current_token)
{
display_message(WARNING_MESSAGE, "Missing region path and/or field name");
display_parse_state_location(state);
return_code = 0;
}
else if (Parse_state_help_mode(state))
{
display_message(INFORMATION_MESSAGE, " REGION_PATH|REGION_PATH/FIELD_NAME|FIELD_NAME");
return_code = 1;
}
else if (Cmiss_region_get_partial_region_path(root_region, current_token,
&name_data->region, &name_data->region_path, &name_data->name))
{
ACCESS(Cmiss_region)(name_data->region);
if (!name_data->name || (NULL == strchr(name_data->name, CMISS_REGION_PATH_SEPARATOR_CHAR)))
{
return_code = shift_Parse_state(state, 1);
}
else
{
display_message(ERROR_MESSAGE, "Bad region path and/or field name: %s",current_token);
display_parse_state_location(state);
return_code = 0;
}
}
else
{
display_message(ERROR_MESSAGE,
"set_region_path_and_or_field_name. Failed to get path and name");
return_code = 0;
}
}
else
{
display_message(ERROR_MESSAGE,
"set_region_path_and_or_field_name. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
}
static int set_Cmiss_mesh(struct Parse_state *state, void *region_void, void *mesh_address_void)
{
Cmiss_region_id region = reinterpret_cast<Cmiss_region_id>(region_void);
Cmiss_mesh_id *mesh_address = reinterpret_cast<Cmiss_mesh_id*>(mesh_address_void);
if (!(state && region && mesh_address))
return 0;
const char *current_token = state->current_token;
int return_code = 1;
if (!current_token)
{
display_message(WARNING_MESSAGE, "Missing mesh name");
display_parse_state_location(state);
return_code = 0;
}
else if ((0 == strcmp(PARSER_HELP_STRING, current_token)) ||
(0 == strcmp(PARSER_RECURSIVE_HELP_STRING, current_token)))
{
display_message(INFORMATION_MESSAGE, " ELEMENT_GROUP_FIELD_NAME|[GROUP_NAME.]cmiss_mesh_1d|cmiss_mesh_2d|cmiss_mesh_3d[");
if (*mesh_address)
{
char *mesh_name = Cmiss_mesh_get_name(*mesh_address);
make_valid_token(&mesh_name);
display_message(INFORMATION_MESSAGE, "%s]", mesh_name);
DEALLOCATE(mesh_name);
}
else
{
display_message(INFORMATION_MESSAGE, "none]");
}
}
else
{
Cmiss_field_module_id field_module = Cmiss_region_get_field_module(region);
Cmiss_mesh_id new_mesh = Cmiss_field_module_find_mesh_by_name(field_module, current_token);
if (new_mesh)
{
if (*mesh_address)
Cmiss_mesh_destroy(mesh_address);
*mesh_address = new_mesh;
shift_Parse_state(state, 1);
}
else
{
display_message(ERROR_MESSAGE, "Invalid mesh: %s", current_token);
display_parse_state_location(state);
return_code = 0;
}
Cmiss_field_module_destroy(&field_module);
}
return return_code;
}
int define_Computed_field_type_connected_threshold_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_CONNECTED_THRESHOLD_IMAGE_FILTER (if it is not
already) and allows its contents to be modified.
==============================================================================*/
{
double lower_threshold, upper_threshold, replace_value;
int num_seed_points;
int seed_dimension;
double *seed_points;
int return_code;
int seed_points_length;
int previous_state_index, expected_parameters;
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_connected_threshold_image_filter);
USE_PARAMETER(computed_field_simple_package_void);
if (state && (field_modify=(Computed_field_modify_data *)field_modify_void))
{
return_code = 1;
source_field = (struct Computed_field *)NULL;
lower_threshold = 0.0;
upper_threshold = 1.0;
replace_value = 1;
num_seed_points = 0;
seed_dimension = 2;
seed_points = (double *)NULL;
// should probably default to having 1 seed point
// seed_points[0] = 0.5; // pjb: is this ok?
// seed_points[1] = 0.5;
seed_points_length = 0;
/* get valid parameters for projection field */
if ((NULL != field_modify->get_field()) &&
(computed_field_connected_threshold_image_filter_type_string ==
Computed_field_get_type_string(field_modify->get_field())))
{
return_code =
Cmiss_field_get_type_connected_threshold_image_filter(field_modify->get_field(), &source_field,
&lower_threshold, &upper_threshold, &replace_value,
&num_seed_points, &seed_dimension, &seed_points);
}
if (return_code)
{
if (source_field)
{
ACCESS(Computed_field)(source_field);
}
if (state->current_token &&
(!(strcmp(PARSER_HELP_STRING, state->current_token)&&
strcmp(PARSER_RECURSIVE_HELP_STRING, state->current_token))))
{
/* Handle help separately */
option_table = CREATE(Option_table)();
Option_table_add_help(option_table,
"The connected_threshold_filter field uses the itk::ConnectedThresholdImageFilter code to segment a field. The <field> it operates on is usually a sample_texture field, based on a texture that has been created from image file(s). The segmentation is based on a region growing algorithm which requires at least one seed point. To specify the seed points first set the <num_seed_points> and the <dimension> of the image. The <seed_points> are a list of the coordinates for the first and any subsequent seed points. Starting from the seed points any neighbouring pixels with an intensity between <lower_threshold> and the <upper_threshold> are added to the region. Pixels within the region have their pixel intensity set to <replace_value> while the remaining pixels are set to 0. 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);
/* lower_threshold */
Option_table_add_double_entry(option_table, "lower_threshold",
&lower_threshold);
/* upper_threshold */
Option_table_add_double_entry(option_table, "upper_threshold",
&upper_threshold);
/* replace_value */
Option_table_add_double_entry(option_table, "replace_value",
&replace_value);
/* num_seed_points */
Option_table_add_int_positive_entry(option_table, "num_seed_points",
&num_seed_points);
Option_table_add_int_positive_entry(option_table, "dimension",
&seed_dimension);
Option_table_add_double_vector_entry(option_table, "seed_points",
seed_points, &seed_points_length);
return_code = Option_table_multi_parse(option_table, state);
DESTROY(Option_table)(&option_table);
}
if (return_code)
{
// store previous state so that we can return to it
previous_state_index = state->current_index;
/* parse the two options which determine the number of seed values
and hence the size of the array that must be created to read in
the number of seed values. */
option_table = CREATE(Option_table)();
/* num_seed_points */
Option_table_add_int_positive_entry(option_table, "num_seed_points",
&num_seed_points);
/* dimension */
Option_table_add_int_positive_entry(option_table, "dimension",
&seed_dimension);
/* Ignore all the other entries */
Option_table_ignore_all_unmatched_entries(option_table);
return_code = Option_table_multi_parse(option_table, state);
DESTROY(Option_table)(&option_table);
/* Return back to where we were */
shift_Parse_state(state, previous_state_index - state->current_index);
}
/* parse the rest of the table */
if (return_code)
{
seed_points_length = num_seed_points * seed_dimension;
REALLOCATE(seed_points, seed_points, double, seed_points_length);
// pjb: should I populate array with dummy values?
option_table = CREATE(Option_table)();
/* 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);
/* lower_threshold */
Option_table_add_double_entry(option_table, "lower_threshold",
&lower_threshold);
/* upper_threshold */
Option_table_add_double_entry(option_table, "upper_threshold",
&upper_threshold);
/* replace_value */
Option_table_add_double_entry(option_table, "replace_value",
&replace_value);
expected_parameters = 1;
Option_table_add_ignore_token_entry(option_table, "num_seed_points",
&expected_parameters);
expected_parameters = 1;
Option_table_add_ignore_token_entry(option_table, "dimension",
&expected_parameters);
Option_table_add_double_vector_entry(option_table, "seed_points",
seed_points, &seed_points_length);
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_connected_threshold_image_filter. "
"Missing source field");
return_code = 0;
}
}
if (return_code)
{
return_code = field_modify->update_field_and_deaccess(
Cmiss_field_module_create_connected_threshold_image_filter(
field_modify->get_field_module(),
source_field, lower_threshold, upper_threshold, replace_value,
num_seed_points, seed_dimension, seed_points));
}
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_connected_threshold_image_filter. Failed");
}
}
if (source_field)
{
DEACCESS(Computed_field)(&source_field);
}
if (seed_points) {
DEALLOCATE(seed_points);
}
}
}
else
{
display_message(ERROR_MESSAGE,
"define_Computed_field_type_connected_threshold_image_filter. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* define_Computed_field_type_connected_threshold_image_filter */
int define_Computed_field_type_mean_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_MEANIMAGEFILTER (if it is not
already) and allows its contents to be modified.
==============================================================================*/
{
int dimension, expected_parameters, i, old_dimension, previous_state_index,
*radius_sizes, return_code, *sizes;
struct Computed_field *source_field, *texture_coordinate_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_mean_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_sizes = (int *)NULL;
old_dimension = 0;
if ((NULL != field_modify->get_field()) &&
(computed_field_mean_image_filter_type_string ==
Computed_field_get_type_string(field_modify->get_field())))
{
return_code =
cmzn_field_get_type_mean_image_filter(field_modify->get_field(), &source_field,
&radius_sizes);
return_code = Computed_field_get_native_resolution(source_field,
&old_dimension, &sizes, &texture_coordinate_field);
if (return_code)
{
DEALLOCATE(sizes);
}
}
if (return_code)
{
/* must access objects for set functions */
if (source_field)
{
ACCESS(Computed_field)(source_field);
}
if ((!state->current_token) ||
(strcmp(PARSER_HELP_STRING, state->current_token)&&
strcmp(PARSER_RECURSIVE_HELP_STRING, state->current_token)))
{
previous_state_index = state->current_index;
/* Discover the source field */
option_table = CREATE(Option_table)();
/* field */
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);
/* Ignore all the other entries */
Option_table_ignore_all_unmatched_entries(option_table);
return_code = Option_table_multi_parse(option_table, state);
DESTROY(Option_table)(&option_table);
/* Return back to where we were */
shift_Parse_state(state, previous_state_index - state->current_index);
/* no errors,not asking for help */
if (return_code)
{
if (!source_field)
{
display_message(ERROR_MESSAGE,
"define_Computed_field_type_mean_image_filter. "
"Missing source field");
return_code = 0;
}
}
if (return_code)
{
return_code = Computed_field_get_native_resolution(source_field,
&dimension, &sizes, &texture_coordinate_field);
if (return_code)
{
DEALLOCATE(sizes);
if (!radius_sizes || (old_dimension != dimension))
{
REALLOCATE(radius_sizes, radius_sizes, int, dimension);
for (i = old_dimension ; i < dimension ; i++)
{
radius_sizes[i] = 1;
}
}
/* Read the radius sizes */
option_table = CREATE(Option_table)();
/* field */
expected_parameters = 1;
Option_table_add_ignore_token_entry(option_table, "field",
&expected_parameters);
/* radius_sizes */
Option_table_add_int_vector_entry(option_table,
"radius_sizes", radius_sizes, &dimension);
return_code = Option_table_multi_parse(option_table, state);
DESTROY(Option_table)(&option_table);
}
else
{
display_message(ERROR_MESSAGE,
"define_Computed_field_type_mean_image_filter. "
"Source field does not have an image dimension.");
return_code = 0;
}
}
if (return_code)
{
return_code = field_modify->update_field_and_deaccess(
cmzn_fieldmodule_create_field_imagefilter_mean(
field_modify->get_field_module(),
source_field, dimension, radius_sizes));
}
if (!return_code)
{
/* error */
display_message(ERROR_MESSAGE,
"define_Computed_field_type_mean_image_filter. Failed");
}
}
else
{
/* Write help */
option_table = CREATE(Option_table)();
Option_table_add_help(option_table,
"The mean_filter field uses the itk::MeanImageFilter code to replace each pixel with the mean intensity of the pixel and its surrounding neighbours. It is useful for reducing the level of noise. The <field> it operates on is usually a sample_texture field, based on a texture that has been created from image file(s). The size of the neighbourhood of pixels used to calculate the mean is determined be a list of <radius_sizes>, one value for each dimension. Each radius size sets how many pixels to include either side of the central pixel for the corresponding dimension. If radius values are increased, more neighbouring pixels are included and the image becomes smoother. 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_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);
/* radius_sizes */
Option_table_add_int_vector_entry(option_table,
"radius_sizes", radius_sizes, &dimension);
return_code = Option_table_multi_parse(option_table, state);
DESTROY(Option_table)(&option_table);
}
if (source_field)
{
DEACCESS(Computed_field)(&source_field);
}
if (radius_sizes)
{
DEALLOCATE(radius_sizes);
}
}
}
else
{
display_message(ERROR_MESSAGE,
"define_Computed_field_type_mean_image_filter. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* define_Computed_field_type_mean_image_filter */
/**
* 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 set_Glyph(struct Parse_state *state, void *glyphAddress_void,
void *glyphmodule_void)
{
int return_code;
cmzn_glyph **glyphAddress = reinterpret_cast<cmzn_glyph **>(glyphAddress_void);
cmzn_glyphmodule *glyphmodule = reinterpret_cast<cmzn_glyphmodule *>(glyphmodule_void);
if (state && glyphAddress && glyphmodule)
{
const char *current_token = state->current_token;
if (current_token)
{
if (!Parse_state_help_mode(state))
{
if (fuzzy_string_compare(current_token, "NONE"))
{
if (*glyphAddress)
{
cmzn_glyph_destroy(glyphAddress);
}
return_code=1;
}
else
{
cmzn_glyph *glyph = cmzn_glyphmodule_find_glyph_by_name(glyphmodule, current_token);
if (glyph)
{
if (*glyphAddress)
{
cmzn_glyph_destroy(glyphAddress);
}
*glyphAddress = glyph;
return_code = 1;
}
else
{
display_message(ERROR_MESSAGE, "Unknown glyph : %s", current_token);
return_code = 0;
}
}
shift_Parse_state(state, 1);
}
else
{
display_message(INFORMATION_MESSAGE," GLYPH_NAME|none");
/* if possible, then write the name */
cmzn_glyph *glyph = *glyphAddress;
if (glyph)
{
display_message(INFORMATION_MESSAGE, "[%s]", glyph->getName());
}
else
{
display_message(INFORMATION_MESSAGE, "[none]");
}
return_code = 1;
}
}
else
{
display_message(WARNING_MESSAGE, "Missing glyph name");
display_parse_state_location(state);
return_code = 0;
}
}
else
{
display_message(ERROR_MESSAGE, "set_Glyph. Invalid argument(s)");
return_code = 0;
}
return (return_code);
}
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_fast_marching_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_FAST_MARCHING_IMAGE_FILTER (if it is not
already) and allows its contents to be modified.
==============================================================================*/
{
double stopping_value;
int num_seed_points;
int dimension;
double *seed_points;
double *seed_values;
int *output_size;
int length_seed_points;
int return_code;
int previous_state_index;
int i;
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_fast_marching_image_filter);
USE_PARAMETER(computed_field_simple_package_void);
if (state && (field_modify=(Computed_field_modify_data *)field_modify_void))
{
return_code = 1;
source_field = (struct Computed_field *)NULL;
stopping_value = 100;
num_seed_points = 1;
dimension = 2;
length_seed_points = num_seed_points * dimension;
seed_points = (double *)NULL;
seed_values = (double *)NULL;
output_size = (int *)NULL;
ALLOCATE(seed_points, double, length_seed_points);
ALLOCATE(seed_values, double, num_seed_points);
ALLOCATE(output_size, int, dimension);
// should probably default to having 1 seed
seed_points[0] = 0.5; // pjb: is this ok?
seed_points[1] = 0.5;
seed_values[0] = 0.0;
output_size[0] = 128;
output_size[1] = 128;
/* get valid parameters for projection field */
if ((NULL != field_modify->get_field()) &&
(computed_field_fast_marching_image_filter_type_string ==
Computed_field_get_type_string(field_modify->get_field())))
{
return_code =
cmzn_field_get_type_fast_marching_image_filter(field_modify->get_field(), &source_field,
&stopping_value, &num_seed_points, &dimension, &seed_points, &seed_values, &output_size);
}
if (return_code)
{
if (source_field)
{
ACCESS(Computed_field)(source_field);
}
if (state->current_token &&
(!(strcmp(PARSER_HELP_STRING, state->current_token)&&
strcmp(PARSER_RECURSIVE_HELP_STRING, state->current_token))))
{
/* Handle help separately */
option_table = CREATE(Option_table)();
Option_table_add_help(option_table,
"The fast_marching_filter field uses the itk::FastMarchingImageFilter code to segment a field. The segmentation is based on a level set algorithm. The <field> it operates on is used as a speed term, to govern where the level set curve grows quickly. The speed term is usually some function (eg a sigmoid) of an image gradient field. The output field is a time crossing map, where the value at is each pixel is the time take to reach that location from the specified seed points. Values typically range from 0 through to extremely large (10 to the 38). To convert the time cross map into a segmented region use a binary threshold filter. To specify the seed points first set the <num_seed_points> and the <dimension> of the image. The <seed_points> are a list of the coordinates for the first and any subsequent seed points. It is also possible to specify non-zero initial <seed_values> if desired and to set the <output_size> of the time crossing map. See a/segmentation 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);
/* stopping_value */
Option_table_add_double_entry(option_table, "stopping_value",
&stopping_value);
/* num_seed_points */
Option_table_add_int_positive_entry(option_table, "num_seed_points",
&num_seed_points);
/* dimension */
Option_table_add_int_positive_entry(option_table, "dimension",
&dimension);
/* seed_points */
Option_table_add_double_vector_entry(option_table, "seed_points",
seed_points, &length_seed_points);
/* seed_values */
Option_table_add_double_vector_entry(option_table, "seed_values",
seed_values, &num_seed_points);
/* output_size */
Option_table_add_int_vector_entry(option_table, "output_size",
output_size, &dimension);
return_code = Option_table_multi_parse(option_table, state);
DESTROY(Option_table)(&option_table);
}
if (return_code)
{
// store previous state so that we can return to it
previous_state_index = state->current_index;
/* parse the two options which determine the number of seed values
and hence the size of the array that must be created to read in
the number of seed values. */
option_table = CREATE(Option_table)();
/* num_seed_points */
Option_table_add_int_positive_entry(option_table, "num_seed_points",
&num_seed_points);
/* dimension */
Option_table_add_int_positive_entry(option_table, "dimension",
&dimension);
/* Ignore all the other entries */
Option_table_ignore_all_unmatched_entries(option_table);
return_code = Option_table_multi_parse(option_table, state);
DESTROY(Option_table)(&option_table);
/* Return back to where we were */
shift_Parse_state(state, previous_state_index - state->current_index);
}
/* parse the rest of the table */
if (return_code)
{
length_seed_points = num_seed_points * dimension;
/* reallocate memory for arrays */
REALLOCATE(seed_points, seed_points, double, length_seed_points);
REALLOCATE(seed_values, seed_values, double, num_seed_points);
REALLOCATE(output_size, output_size, int, dimension);
/* set default values, in case options are not specified in field definition. */
for (i=0; i < length_seed_points ;i++) {
seed_points[i] = 0;
}
for (i=0; i < num_seed_points ;i++) {
seed_values[i] = 0;
}
for (i=0; i < dimension ;i++) {
output_size[i] = 128;
}
option_table = CREATE(Option_table)();
/* 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);
/* stopping_value */
Option_table_add_double_entry(option_table, "stopping_value",
&stopping_value);
int num_seed_points_expected_parameters = 1;
Option_table_add_ignore_token_entry(option_table, "num_seed_points",
&num_seed_points_expected_parameters);
int dimension_expected_parameters = 1;
Option_table_add_ignore_token_entry(option_table, "dimension",
&dimension_expected_parameters);
Option_table_add_double_vector_entry(option_table, "seed_points",
seed_points, &length_seed_points);
Option_table_add_double_vector_entry(option_table, "seed_values",
seed_values, &num_seed_points);
Option_table_add_int_vector_entry(option_table, "output_size",
output_size, &dimension);
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_fast_marching_image_filter. "
"Missing source field");
return_code = 0;
}
}
if (return_code)
{
return_code = field_modify->update_field_and_deaccess(
cmzn_fieldmodule_create_field_imagefilter_fast_marching(
field_modify->get_field_module(),
source_field, stopping_value, num_seed_points, dimension,
seed_points, seed_values, output_size));
}
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_fast_marching_image_filter. Failed");
}
}
if (source_field)
{
DEACCESS(Computed_field)(&source_field);
}
if (seed_points) {
DEALLOCATE(seed_points);
}
if (seed_values) {
DEALLOCATE(seed_values);
}
if (output_size) {
DEALLOCATE(output_size);
}
}
}
else
{
display_message(ERROR_MESSAGE,
"define_Computed_field_type_fast_marching_image_filter. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* define_Computed_field_type_fast_marching_image_filter */
int define_Computed_field_type_histogram_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 i, original_number_of_components, previous_state_index, return_code;
int *numberOfBins;
double marginalScale, *histogramMinimum, *histogramMaximum;
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_histogram_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;
numberOfBins = (int *)NULL;
histogramMinimum = (double *)NULL;
histogramMaximum = (double *)NULL;
marginalScale = 10.0;
original_number_of_components = 0;
if ((NULL != field_modify->get_field()) &&
(computed_field_histogram_image_filter_type_string ==
Computed_field_get_type_string(field_modify->get_field())))
{
return_code =
Cmiss_field_get_type_histogram_image_filter(field_modify->get_field(), &source_field,
&numberOfBins, &marginalScale, &histogramMinimum, &histogramMaximum);
original_number_of_components = source_field->number_of_components;
}
if (return_code)
{
/* must access objects for set functions */
if (source_field)
{
ACCESS(Computed_field)(source_field);
}
if (state->current_token &&
(!(strcmp(PARSER_HELP_STRING, state->current_token)&&
strcmp(PARSER_RECURSIVE_HELP_STRING, state->current_token))))
{
/* Handle help separately */
option_table = CREATE(Option_table)();
Option_table_add_help(option_table,
"The histogram_filter field uses the itk::ImageToHistogramGenerator code to generate binned values representing the relative frequency of the various pixel intensities. There should be a number_of_bins for each component direction, and so the total number of bins will be a product of these, so that for a 3 component image you would get a volume histogram. "
"If you wanted a histogram for a single component then set the number_of_bins for the other components to 1. "
"If you do not set the optional histogram_minimums or histogram_maximums (which is a vector of values, 1 for each source component) then the histogram will automatically range the values to the minimum and maximum values in the source image.");
/* field */
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);
/* histogramMinimum */
double dummyHistogramMinimum = 0.0;
Option_table_add_double_entry(option_table, "histogram_minimums",
&dummyHistogramMinimum);
/* histogramMinimum */
double dummyHistogramMaximum = 1.0;
Option_table_add_double_entry(option_table, "histogram_maximums",
&dummyHistogramMaximum);
/* numberOfBins */
int dummyNumberOfBins = 64;
Option_table_add_int_positive_entry(option_table, "number_of_bins",
&dummyNumberOfBins);
/* marginalScale */
Option_table_add_double_entry(option_table, "marginal_scale",
&marginalScale);
return_code = Option_table_multi_parse(option_table, state);
DESTROY(Option_table)(&option_table);
}
if (return_code)
{
// store previous state so that we can return to it
previous_state_index = state->current_index;
/* parse the source field so we know the dimension. */
option_table = CREATE(Option_table)();
/* field */
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);
/* Ignore all the other entries */
Option_table_ignore_all_unmatched_entries(option_table);
return_code = Option_table_multi_parse(option_table, state);
DESTROY(Option_table)(&option_table);
/* Return back to where we were */
shift_Parse_state(state, previous_state_index - state->current_index);
if (!source_field)
{
display_message(ERROR_MESSAGE,
"define_Computed_field_type_histogram_image_filter. "
"Missing source field");
return_code = 0;
}
}
if (return_code)
{
if (source_field->number_of_components != original_number_of_components)
{
REALLOCATE(numberOfBins, numberOfBins, int,
source_field->number_of_components);
for (i = 0 ; i < source_field->number_of_components ; i++)
{
numberOfBins[i] = 64;
}
}
option_table = CREATE(Option_table)();
/* field, ignore as we have already got it */
int field_expected_parameters = 1;
Option_table_add_ignore_token_entry(
option_table, "field", &field_expected_parameters);
/* histogramMinimum */
int histogramMinimumLength = 0;
if (histogramMinimum)
histogramMinimumLength = original_number_of_components;
Option_table_add_variable_length_double_vector_entry(option_table, "histogram_minimums",
&histogramMinimumLength, &histogramMinimum);
/* histogramMaximum */
int histogramMaximumLength = 0;
if (histogramMaximum)
histogramMaximumLength = original_number_of_components;
Option_table_add_variable_length_double_vector_entry(option_table, "histogram_maximums",
&histogramMaximumLength, &histogramMaximum);
/* numberOfBins */
Option_table_add_int_vector_entry(option_table, "number_of_bins",
numberOfBins, &source_field->number_of_components);
/* marginalScale */
Option_table_add_double_entry(option_table, "marginal_scale",
&marginalScale);
return_code = Option_table_multi_parse(option_table, state);
DESTROY(Option_table)(&option_table);
if (histogramMinimum && histogramMinimumLength != source_field->number_of_components)
{
display_message(ERROR_MESSAGE,
"define_Computed_field_type_histogram_image_filter. Length of histogram_minimums vector does not match source field compontents");
return_code = 0;
}
if (histogramMaximum && histogramMaximumLength != source_field->number_of_components)
{
display_message(ERROR_MESSAGE,
"define_Computed_field_type_histogram_image_filter. Length of histogram_Maximums vector does not match source field compontents");
return_code = 0;
}
if (return_code)
{
return_code = field_modify->update_field_and_deaccess(
Cmiss_field_module_create_histogram_image_filter(
field_modify->get_field_module(),
source_field, numberOfBins, marginalScale, histogramMinimum, histogramMaximum));
}
if (!return_code)
{
/* error */
display_message(ERROR_MESSAGE,
"define_Computed_field_type_histogram_image_filter. Failed");
}
}
if (source_field)
{
DEACCESS(Computed_field)(&source_field);
}
if (numberOfBins)
{
DEALLOCATE(numberOfBins);
}
}
int set_Cmiss_region_path(struct Parse_state *state, void *path_address_void,
void *root_region_void)
/*******************************************************************************
LAST MODIFIED : 13 January 2003
DESCRIPTION :
Modifier function for entering a path to a Cmiss_region, starting at
<root_region>.
==============================================================================*/
{
const char *current_token;
char **path_address;
int return_code;
struct Cmiss_region *region, *root_region;
ENTER(set_Cmiss_region_path);
if (state && (root_region = (struct Cmiss_region *)root_region_void))
{
if ((current_token = state->current_token))
{
if (!Parse_state_help_mode(state))
{
region = Cmiss_region_find_subregion_at_path(
root_region, current_token);
if (region)
{
if ((path_address = (char **)path_address_void))
{
if (*path_address)
{
DEALLOCATE(*path_address);
}
if ((*path_address = duplicate_string(current_token)))
{
return_code = shift_Parse_state(state, 1);
}
else
{
display_message(ERROR_MESSAGE,
"set_Cmiss_region_path. Could not allocate memory for path");
return_code = 0;
}
}
else
{
display_message(ERROR_MESSAGE,
"set_Cmiss_region_path. Missing path_address");
return_code = 0;
}
DEACCESS(Cmiss_region)(®ion);
}
else
{
display_message(ERROR_MESSAGE, "Invalid region path: %s",
current_token);
display_parse_state_location(state);
return_code = 0;
}
}
else
{
display_message(INFORMATION_MESSAGE," PATH_TO_REGION");
if ((path_address = (char **)path_address_void) && (*path_address))
{
display_message(INFORMATION_MESSAGE, "[%s]", *path_address);
}
return_code = 1;
}
}
else
{
display_message(ERROR_MESSAGE, "Missing region path");
display_parse_state_location(state);
return_code = 0;
}
}
else
{
display_message(ERROR_MESSAGE, "set_Cmiss_region_path. Missing state");
return_code = 0;
}
LEAVE;
return (return_code);
} /* set_Cmiss_region_path */
int set_Spectrum(struct Parse_state *state,void *spectrum_address_void,
void *spectrum_manager_void)
/*******************************************************************************
LAST MODIFIED : 22 June 1999
DESCRIPTION :
A modifier function to set the spectrum by finding in the spectrum manager
the name given in the next token of the parser
==============================================================================*/
{
const char *current_token;
int return_code;
struct Spectrum *temp_spectrum,**spectrum_address;
struct MANAGER(Spectrum) *spectrum_manager;
ENTER(set_Spectrum);
if (state)
{
current_token=state->current_token;
if (current_token)
{
if (strcmp(PARSER_HELP_STRING,current_token)&&
strcmp(PARSER_RECURSIVE_HELP_STRING,current_token))
{
spectrum_address=(struct Spectrum **)spectrum_address_void;
spectrum_manager=(struct MANAGER(Spectrum) *)spectrum_manager_void;
if (spectrum_address && spectrum_manager)
{
if (fuzzy_string_compare(current_token,"NONE"))
{
if (*spectrum_address)
{
DEACCESS(Spectrum)(spectrum_address);
*spectrum_address=(struct Spectrum *)NULL;
}
return_code=1;
}
else
{
temp_spectrum=FIND_BY_IDENTIFIER_IN_MANAGER(Spectrum, name)(current_token,spectrum_manager);
if (temp_spectrum)
{
if (*spectrum_address!=temp_spectrum)
{
DEACCESS(Spectrum)(spectrum_address);
*spectrum_address=ACCESS(Spectrum)(temp_spectrum);
}
return_code=1;
}
else
{
display_message(ERROR_MESSAGE,"Unknown spectrum : %s",
current_token);
return_code=0;
}
}
shift_Parse_state(state,1);
}
else
{
display_message(ERROR_MESSAGE,
"set_Spectrum. Invalid argument(s). spectrum_address %p. spectrum_manager %p",
spectrum_address_void,spectrum_manager_void);
return_code=0;
}
}
else
{
display_message(INFORMATION_MESSAGE," SPECTRUM_NAME|none");
/* if possible, then write the name */
spectrum_address = (struct Spectrum **)spectrum_address_void;
if (spectrum_address)
{
temp_spectrum = *spectrum_address;
if (temp_spectrum)
{
display_message(INFORMATION_MESSAGE,"[%s]",temp_spectrum->name);
}
else
{
display_message(INFORMATION_MESSAGE,"[none]");
}
}
return_code=1;
}
}
