int define_Computed_field_type_canny_edge_detection_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_CANNYEDGEDETECTIONFILTER (if it is not
already) and allows its contents to be modified.
==============================================================================*/
{
int return_code;
double variance;
double maximumError;
double upperThreshold;
double lowerThreshold;
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_canny_edge_detection_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;
variance = 0;
maximumError = 0.01;
upperThreshold = 0;
lowerThreshold = 0;
if ((NULL != field_modify->get_field()) &&
(computed_field_canny_edge_detection_image_filter_type_string ==
Computed_field_get_type_string(field_modify->get_field())))
{
return_code =
cmzn_field_get_type_canny_edge_detection_image_filter(field_modify->get_field(), &source_field,
&variance, &maximumError, &upperThreshold, &lowerThreshold);
}
if (return_code)
{
/* must access objects for set functions */
if (source_field)
{
ACCESS(Computed_field)(source_field);
}
/* Discover the source field */
option_table = CREATE(Option_table)();
Option_table_add_help(option_table,
"The canny_edge_detection field uses the itk::CannyEdgeDetectionImageFilter code to detect edges in 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). Increasing the <variance> smooths the input image more, which reduces sensitivity to image noise at the expense of losing some detail. Decreasing the <maximum_error> also reduces edges detected as the result of noise. The <upper_threshold> sets the level which a point must be above to use it as the start of the edge. The edge will then grow from that point until the level drops below the <lower_threshold>. Increasing the <upper_threshold> will decrease the number of edges detected. Increasing the <lower_threshold> will reduce the length of edges. See a/testing/image_processing_2D for an example of using this field.");
/* 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);
/* variance */
Option_table_add_double_entry(option_table, "variance",
&variance);
/* maximumError */
Option_table_add_double_entry(option_table, "maximum_error",
&maximumError);
/* upperThreshold */
Option_table_add_double_entry(option_table, "upper_threshold",
&upperThreshold);
/* lowerThreshold */
Option_table_add_double_entry(option_table, "lower_threshold",
&lowerThreshold);
return_code = Option_table_multi_parse(option_table, state);
DESTROY(Option_table)(&option_table);
if (return_code)
{
if (!source_field)
{
display_message(ERROR_MESSAGE,
"define_Computed_field_type_canny_edge_detection_image_filter. "
"Missing source field");
return_code = 0;
}
}
if (return_code)
{
return_code = field_modify->update_field_and_deaccess(
cmzn_fieldmodule_create_field_imagefilter_canny_edge_detection(
field_modify->get_field_module(), source_field, variance,
maximumError, upperThreshold, lowerThreshold));
}
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_canny_edge_detection_image_filter. Failed");
}
}
if (source_field)
{
DEACCESS(Computed_field)(&source_field);
}
}
}
else
{
display_message(ERROR_MESSAGE,
"define_Computed_field_type_canny_edge_detection_image_filter. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* define_Computed_field_type_canny_edge_detection_image_filter */
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_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_sigmoid_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 COMPUTED_FIELD_SIGMOIDIMAGEFILTER (if it is not
already) and allows its contents to be modified.
==============================================================================*/
{
int return_code;
double min, max, alpha, beta;
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_sigmoid_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;
min = 0.0;
max = 1.0;
alpha = 0.25;
beta = 0.5;
if ((NULL != field_modify->get_field()) &&
(computed_field_sigmoid_image_filter_type_string ==
Computed_field_get_type_string(field_modify->get_field())))
{
return_code =
cmzn_field_get_type_sigmoid_image_filter(field_modify->get_field(), &source_field,
&min, &max, &alpha, &beta);
}
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 sigmoid_filter field uses the itk::SigmoidImageFilter code to nonlinearly scale the pixel intensity to vary between the specified minimum and maximum intensity values according to a sigmoid curve. It is useful for focusing attention on a particular set of values while providing a smooth transition at the borders of the range. The <field> it operates on is usually a sample_texture field, based on a texture that has been created from image file(s). Intensity values are rescaled to vary from the <minimum> to the <maximum> value using a sigmoid curve which has a width and centre defined by <alpha> and <beta>. Increasing the <alpha> parameter widens the curve while increasing the <beta> parameter moves the centre of the curve to the right. 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);
/* minimum */
Option_table_add_double_entry(option_table, "minimum",
&min);
/* maximum */
Option_table_add_double_entry(option_table, "maximum",
&max);
/* alpha */
Option_table_add_double_entry(option_table, "alpha",
&alpha);
/* beta */
Option_table_add_double_entry(option_table, "beta",
&beta);
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_sigmoid_image_filter. "
"Missing source field");
return_code = 0;
}
}
if (return_code)
{
return_code = field_modify->update_field_and_deaccess(
cmzn_fieldmodule_create_field_imagefilter_sigmoid(
field_modify->get_field_module(),
source_field, min, max, alpha, beta));
}
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_sigmoid_image_filter. Failed");
}
}
if (source_field)
{
DEACCESS(Computed_field)(&source_field);
}
}
}
else
{
display_message(ERROR_MESSAGE,
"define_Computed_field_type_sigmoid_image_filter. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* define_Computed_field_type_sigmoid_image_filter */
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 define_Computed_field_type_gradient_magnitude_recursive_gaussian_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 GRADIENT_MAGNITUDE_RECURSIVE_GAUSSIAN (if it is not
already) and allows its contents to be modified.
==============================================================================*/
{
int return_code;
double sigma;
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_gradient_magnitude_recursive_gaussian_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;
sigma = 2.0;
if ((NULL != field_modify->get_field()) &&
(computed_field_gradient_magnitude_recursive_gaussian_image_filter_type_string ==
Computed_field_get_type_string(field_modify->get_field())))
{
return_code =
cmzn_field_get_type_gradient_magnitude_recursive_gaussian_image_filter(field_modify->get_field(), &source_field,
&sigma);
}
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 gradient_magnitude_recursive_filter field uses the itk::GradientMagnitudeRecursiveImageFilter code to compute the magnitude of the image gradient at each location in the field. It is useful for identifying regions where the pixel intensities change rapidly. The <field> it operates on is usually a sample_texture field, based on a texture that has been created from image file(s). The filter first smooths the image using a discrete gaussian image subfilter before calculating the gradient and magnitudes. Increasing <sigma> increases the width of the gaussian distribution used during the smoothing and hence the number of pixels used to calculate the weighted average. This smooths the image more. 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);
/* sigma */
Option_table_add_double_entry(option_table, "sigma",&sigma);
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_gradient_magnitude_recursive_gaussian_image_filter. "
"Missing source field");
return_code = 0;
}
}
if (return_code)
{
return_code = field_modify->update_field_and_deaccess(
cmzn_fieldmodule_create_field_imagefilter_gradient_magnitude_recursive_gaussian(
field_modify->get_field_module(),
source_field, sigma));
}
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_gradient_magnitude_recursive_gaussian_image_filter. Failed");
}
}
if (source_field)
{
DEACCESS(Computed_field)(&source_field);
}
}
}
else
{
display_message(ERROR_MESSAGE,
"define_Computed_field_type_gradient_magnitude_recursive_gaussian_image_filter. Invalid argument(s)");
return_code = 0;
}
LEAVE;
return (return_code);
} /* define_Computed_field_type_gradient_magnitude_recursive_gaussian_image_filter */
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 */
int gfx_modify_rendition_graphic(struct Parse_state *state,
enum Cmiss_graphic_type graphic_type, const char *help_text,
struct Modify_rendition_data *modify_rendition_data,
struct Rendition_command_data *rendition_command_data)
{
if (!(state && rendition_command_data && modify_rendition_data))
{
display_message(ERROR_MESSAGE,
"gfx_modify_rendition_graphic. Invalid argument(s)");
return 0;
}
Cmiss_graphic *graphic = 0;
if (modify_rendition_data->modify_this_graphic)
{
graphic = Cmiss_graphic_access(modify_rendition_data->graphic);
graphic_type = Cmiss_graphic_get_graphic_type(graphic);
}
else
{
graphic = get_graphic_for_gfx_modify(rendition_command_data->rendition,
graphic_type, modify_rendition_data->graphic);
if (modify_rendition_data->group && (!graphic->subgroup_field))
{
graphic->subgroup_field =
Cmiss_field_access(Cmiss_field_group_base_cast(modify_rendition_data->group));
}
}
if (!graphic)
{
display_message(ERROR_MESSAGE,
"gfx_modify_rendition_graphic. Could not create graphic");
return 0;
}
REACCESS(Cmiss_graphic)(&(modify_rendition_data->graphic), graphic);
int return_code = 1;
Cmiss_graphics_coordinate_system coordinate_system = Cmiss_graphic_get_coordinate_system(graphic);
char *font_name = (char *)NULL;
Cmiss_field_id orientation_scale_field = 0;
Cmiss_field_id variable_scale_field = 0;
Cmiss_field_id xi_point_density_field = 0;
GT_object *glyph = 0;
Triple glyph_offset, glyph_scale_factors, glyph_size;
enum Graphic_glyph_scaling_mode glyph_scaling_mode = GRAPHIC_GLYPH_SCALING_GENERAL;
const char *glyph_scaling_mode_string = 0;
if (Cmiss_graphic_type_uses_attribute(graphic_type, CMISS_GRAPHIC_ATTRIBUTE_GLYPH))
{
Cmiss_graphic_get_glyph_parameters(graphic,
&glyph, &glyph_scaling_mode, glyph_offset, glyph_size,
&orientation_scale_field, glyph_scale_factors,
&variable_scale_field);
if (glyph)
ACCESS(GT_object)(glyph);
if (orientation_scale_field)
{
ACCESS(Computed_field)(orientation_scale_field);
}
if (variable_scale_field)
{
ACCESS(Computed_field)(variable_scale_field);
}
glyph_scaling_mode_string = ENUMERATOR_STRING(Graphic_glyph_scaling_mode)(glyph_scaling_mode);
}
enum Use_element_type use_element_type;
const char *use_element_type_string = 0;
if (Cmiss_graphic_type_uses_attribute(graphic_type, CMISS_GRAPHIC_ATTRIBUTE_USE_ELEMENT_TYPE))
{
use_element_type = graphic->use_element_type;
use_element_type_string = ENUMERATOR_STRING(Use_element_type)(use_element_type);
}
enum Xi_discretization_mode xi_discretization_mode;
const char *xi_discretization_mode_string = 0;
if (Cmiss_graphic_type_uses_attribute(graphic_type, CMISS_GRAPHIC_ATTRIBUTE_XI_DISCRETIZATION_MODE))
{
Cmiss_graphic_get_xi_discretization(graphic,
&xi_discretization_mode, &xi_point_density_field);
if (xi_point_density_field)
{
ACCESS(Computed_field)(xi_point_density_field);
}
xi_discretization_mode_string = ENUMERATOR_STRING(Xi_discretization_mode)(xi_discretization_mode);
}
int number_of_components = 3;
int visibility = graphic->visibility_flag;
int number_of_valid_strings;
const char **valid_strings;
enum Cmiss_graphics_render_type render_type = graphic->render_type;
const char *render_type_string = ENUMERATOR_STRING(Cmiss_graphics_render_type)(render_type);
/* The value stored in the graphic is an integer rather than a char */
char reverse_track = (graphic->reverse_track) ? 1 : 0;
char *seed_nodeset_name = 0;
if (graphic->seed_nodeset)
{
seed_nodeset_name = Cmiss_nodeset_get_name(graphic->seed_nodeset);
}
Option_table *option_table = CREATE(Option_table)();
if (help_text)
{
Option_table_add_help(option_table, help_text);
}
/* as */
Option_table_add_entry(option_table,"as",&(graphic->name),
(void *)1,set_name);
/* cell_centres/cell_corners/cell_density/exact_xi */
if (Cmiss_graphic_type_uses_attribute(graphic_type, CMISS_GRAPHIC_ATTRIBUTE_XI_DISCRETIZATION_MODE))
{
valid_strings = ENUMERATOR_GET_VALID_STRINGS(Xi_discretization_mode)(
&number_of_valid_strings,
(ENUMERATOR_CONDITIONAL_FUNCTION(Xi_discretization_mode) *)NULL,
(void *)NULL);
Option_table_add_enumerator(option_table,number_of_valid_strings,
valid_strings,&xi_discretization_mode_string);
DEALLOCATE(valid_strings);
}
/* centre */
if (Cmiss_graphic_type_uses_attribute(graphic_type, CMISS_GRAPHIC_ATTRIBUTE_GLYPH))
{
Option_table_add_entry(option_table,"centre",glyph_offset,
&(number_of_components),set_reversed_float_vector);
}
/* circle_discretization */
if (graphic_type == CMISS_GRAPHIC_CYLINDERS)
{
Option_table_add_entry(option_table, "circle_discretization",
(void *)&(graphic->circle_discretization), (void *)NULL,
set_Circle_discretization);
}
/* constant_radius */
if (graphic_type == CMISS_GRAPHIC_CYLINDERS)
{
Option_table_add_entry(option_table,"constant_radius",
&(graphic->constant_radius),NULL,set_float);
}
/* coordinate */
Set_Computed_field_conditional_data set_coordinate_field_data;
set_coordinate_field_data.computed_field_manager = rendition_command_data->computed_field_manager;
set_coordinate_field_data.conditional_function = Computed_field_has_up_to_3_numerical_components;
set_coordinate_field_data.conditional_function_user_data = (void *)NULL;
Option_table_add_Computed_field_conditional_entry(option_table, "coordinate",
&(graphic->coordinate_field), &set_coordinate_field_data);
/* coordinate system */
const char *coordinate_system_string =
ENUMERATOR_STRING(Cmiss_graphics_coordinate_system)(coordinate_system);
valid_strings = ENUMERATOR_GET_VALID_STRINGS(Cmiss_graphics_coordinate_system)(
&number_of_valid_strings,
(ENUMERATOR_CONDITIONAL_FUNCTION(Cmiss_graphics_coordinate_system) *)NULL,
(void *)NULL);
Option_table_add_enumerator(option_table, number_of_valid_strings,
valid_strings, &coordinate_system_string);
DEALLOCATE(valid_strings);
/* data */
Set_Computed_field_conditional_data set_data_field_data;
set_data_field_data.computed_field_manager = rendition_command_data->computed_field_manager;
set_data_field_data.conditional_function = Computed_field_has_numerical_components;
set_data_field_data.conditional_function_user_data = (void *)NULL;
Option_table_add_Computed_field_conditional_entry(option_table, "data",
&(graphic->data_field), &set_data_field_data);
/* decimation_threshold */
if (graphic_type == CMISS_GRAPHIC_ISO_SURFACES)
{
Option_table_add_double_entry(option_table, "decimation_threshold",
&(graphic->decimation_threshold));
}
/* delete */
Option_table_add_entry(option_table,"delete",
&(modify_rendition_data->delete_flag),NULL,set_char_flag);
/* density */
Set_Computed_field_conditional_data set_xi_point_density_field_data;
set_xi_point_density_field_data.computed_field_manager = rendition_command_data->computed_field_manager;
set_xi_point_density_field_data.conditional_function = Computed_field_is_scalar;
set_xi_point_density_field_data.conditional_function_user_data = (void *)NULL;
if (Cmiss_graphic_type_uses_attribute(graphic_type, CMISS_GRAPHIC_ATTRIBUTE_XI_DISCRETIZATION_MODE))
{
Option_table_add_Computed_field_conditional_entry(option_table, "density",
&xi_point_density_field, &set_xi_point_density_field_data);
}
/* discretization */
if (Cmiss_graphic_type_uses_attribute(graphic_type, CMISS_GRAPHIC_ATTRIBUTE_DISCRETIZATION))
{
Option_table_add_entry(option_table,"discretization",
&(graphic->discretization),NULL, set_Element_discretization);
}
/* ellipse/line/rectangle/ribbon */
Streamline_type streamline_type = STREAM_LINE;
const char *streamline_type_string = ENUMERATOR_STRING(Streamline_type)(streamline_type);
if (graphic_type == CMISS_GRAPHIC_STREAMLINES)
{
valid_strings = ENUMERATOR_GET_VALID_STRINGS(Streamline_type)(
&number_of_valid_strings,
(ENUMERATOR_CONDITIONAL_FUNCTION(Streamline_type) *)NULL,
(void *)NULL);
Option_table_add_enumerator(option_table,number_of_valid_strings,
valid_strings,&streamline_type_string);
DEALLOCATE(valid_strings);
}
