AmitkDataSet

AmitkDataSet

Synopsis

#define             AMITK_DATA_SET_COLOR_TABLE          (ds,
                                                         view_mode)
#define             AMITK_DATA_SET_COLOR_TABLE_INDEPENDENT(ds,
                                                         view_mode)
#define             AMITK_DATA_SET_CONVERSION           (ds)
#define             AMITK_DATA_SET_CYLINDER_FACTOR      (ds)
#define             AMITK_DATA_SET_DICOM_IMAGE_TYPE     (ds)
#define             AMITK_DATA_SET_DIFFUSION_B_VALUE    (ds)
#define             AMITK_DATA_SET_DIFFUSION_DIRECTION  (ds)
#define             AMITK_DATA_SET_DIM                  (ds)
#define             AMITK_DATA_SET_DIM_G                (ds)
#define             AMITK_DATA_SET_DIM_T                (ds)
#define             AMITK_DATA_SET_DIM_X                (ds)
#define             AMITK_DATA_SET_DIM_Y                (ds)
#define             AMITK_DATA_SET_DIM_Z                (ds)
#define             AMITK_DATA_SET_DISPLAYED_CYLINDER_UNIT(ds)
#define             AMITK_DATA_SET_DISPLAYED_DOSE_UNIT  (ds)
#define             AMITK_DATA_SET_DISPLAYED_WEIGHT_UNIT(ds)
#define             AMITK_DATA_SET_DISTRIBUTION         (ds)
#define             AMITK_DATA_SET_DISTRIBUTION_SIZE
#define             AMITK_DATA_SET_DYNAMIC              (ds)
#define             AMITK_DATA_SET_ECHO_TIME            (ds)
#define             AMITK_DATA_SET_FORMAT               (ds)
#define             AMITK_DATA_SET_GATED                (ds)
#define             AMITK_DATA_SET_INJECTED_DOSE        (ds)
#define             AMITK_DATA_SET_INTERPOLATION        (ds)
#define             AMITK_DATA_SET_INVERSION_TIME       (ds)
#define             AMITK_DATA_SET_MODALITY             (ds)
#define             AMITK_DATA_SET_NUM_FRAMES           (ds)
#define             AMITK_DATA_SET_NUM_GATES            (ds)
#define             AMITK_DATA_SET_NUM_VIEW_GATES       (ds)
#define             AMITK_DATA_SET_RAW_DATA             (ds)
#define             AMITK_DATA_SET_RENDERING            (ds)
#define             AMITK_DATA_SET_SCALE_FACTOR         (ds)
#define             AMITK_DATA_SET_SCALING_HAS_INTERCEPT(ds)
#define             AMITK_DATA_SET_SCALING_TYPE         (ds)
#define             AMITK_DATA_SET_SCAN_DATE            (ds)
#define             AMITK_DATA_SET_SCAN_START           (ds)
#define             AMITK_DATA_SET_SERIES_NUMBER        (ds)
#define             AMITK_DATA_SET_SLICE_PARENT         (ds)
#define             AMITK_DATA_SET_SUBJECT_DOB          (ds)
#define             AMITK_DATA_SET_SUBJECT_ID           (ds)
#define             AMITK_DATA_SET_SUBJECT_NAME         (ds)
#define             AMITK_DATA_SET_SUBJECT_ORIENTATION  (ds)
#define             AMITK_DATA_SET_SUBJECT_SEX          (ds)
#define             AMITK_DATA_SET_SUBJECT_WEIGHT       (ds)
#define             AMITK_DATA_SET_THRESHOLDING         (ds)
#define             AMITK_DATA_SET_THRESHOLD_MAX        (ds,
                                                         ref_frame)
#define             AMITK_DATA_SET_THRESHOLD_MIN        (ds,
                                                         ref_frame)
#define             AMITK_DATA_SET_THRESHOLD_REF_FRAME  (ds,
                                                         ref_frame)
#define             AMITK_DATA_SET_THRESHOLD_STYLE      (ds)
#define             AMITK_DATA_SET_THRESHOLD_WINDOW     (ds,
                                                         i_win,
                                                         limit)
#define             AMITK_DATA_SET_TOTAL_PLANES         (ds)
#define             AMITK_DATA_SET_VIEW_END_GATE        (ds)
#define             AMITK_DATA_SET_VIEW_START_GATE      (ds)
#define             AMITK_DATA_SET_VOXEL_SIZE           (ds)
#define             AMITK_DATA_SET_VOXEL_SIZE_X         (ds)
#define             AMITK_DATA_SET_VOXEL_SIZE_Y         (ds)
#define             AMITK_DATA_SET_VOXEL_SIZE_Z         (ds)
#define             AMITK_DATA_SET_VOXEL_VOLUME         (ds)
enum                AmitkConversion;
enum                AmitkCylinderUnit;
struct              AmitkDataSet;
struct              AmitkDataSetClass;
enum                AmitkDoseUnit;
enum                AmitkExportMethod;
enum                AmitkImportMethod;
enum                AmitkInterpolation;
enum                AmitkOperationBinary;
enum                AmitkOperationUnary;
enum                AmitkRendering;
enum                AmitkScalingType;
enum                AmitkSubjectOrientation;
enum                AmitkSubjectSex;
enum                AmitkThresholding;
enum                AmitkWeightUnit;
const gchar *       amitk_conversion_get_name           (const AmitkConversion conversion);
amide_data_t        amitk_cylinder_unit_convert_from    (const amide_data_t cylinder_factor,
                                                         const AmitkCylinderUnit cylinder_unit);
amide_data_t        amitk_cylinder_unit_convert_to      (const amide_data_t MBq_cc_image_units,
                                                         const AmitkCylinderUnit cylinder_unit);
const gchar *       amitk_cylinder_unit_get_name        (const AmitkCylinderUnit cylinder_unit);
void                amitk_data_set_calc_distribution    (AmitkDataSet *ds,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);
void                amitk_data_set_calc_far_corner      (AmitkDataSet *ds);
void                amitk_data_set_calc_min_max         (AmitkDataSet *ds,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);
void                amitk_data_set_calc_min_max_if_needed
                                                        (AmitkDataSet *ds,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);
gboolean            amitk_data_set_export_to_file       (AmitkDataSet *ds,
                                                         const AmitkExportMethod method,
                                                         const int submethod,
                                                         const gchar *filename,
                                                         const gchar *studyname,
                                                         const gboolean resliced,
                                                         const AmitkPoint voxel_size,
                                                         const AmitkVolume *bounding_box,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);
AmitkColorTable     amitk_data_set_get_color_table_to_use
                                                        (AmitkDataSet *ds,
                                                         const AmitkViewMode view_mode);
AmitkDataSet *      amitk_data_set_get_cropped          (const AmitkDataSet *ds,
                                                         const AmitkVoxel start,
                                                         const AmitkVoxel end,
                                                         const AmitkFormat format,
                                                         const AmitkScalingType scaling_type,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);
amide_time_t        amitk_data_set_get_end_time         (const AmitkDataSet *ds,
                                                         const guint frame);
AmitkDataSet *      amitk_data_set_get_filtered         (const AmitkDataSet *ds,
                                                         const AmitkFilter filter_type,
                                                         const gint kernel_size,
                                                         const amide_real_t fwhm,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);
guint               amitk_data_set_get_frame            (const AmitkDataSet *ds,
                                                         const amide_time_t time);
amide_time_t        amitk_data_set_get_frame_duration   (const AmitkDataSet *ds,
                                                         guint frame);
#define             amitk_data_set_get_frame_duration_mem(ds)
amide_data_t        amitk_data_set_get_frame_max        (AmitkDataSet *ds,
                                                         const guint frame);
amide_data_t        amitk_data_set_get_frame_min        (AmitkDataSet *ds,
                                                         const guint frame);
#define             amitk_data_set_get_frame_min_max_mem(ds)
amide_time_t        amitk_data_set_get_gate_time        (const AmitkDataSet *ds,
                                                         const guint gate);
#define             amitk_data_set_get_gate_time_mem    (ds)
amide_data_t        amitk_data_set_get_global_max       (AmitkDataSet *ds);
amide_data_t        amitk_data_set_get_global_min       (AmitkDataSet *ds);
amide_data_t        amitk_data_set_get_internal_scaling_factor
                                                        (const AmitkDataSet *ds,
                                                         const AmitkVoxel i);
amide_data_t        amitk_data_set_get_internal_value   (const AmitkDataSet *ds,
                                                         const AmitkVoxel i);
void                amitk_data_set_get_line_profile     (AmitkDataSet *ds,
                                                         const amide_time_t start,
                                                         const amide_time_t duration,
                                                         const AmitkPoint start_point,
                                                         const AmitkPoint end_point,
                                                         GPtrArray **preturn_data);
amide_data_t        amitk_data_set_get_max              (AmitkDataSet *ds,
                                                         const amide_time_t start,
                                                         const amide_time_t duration);
amide_time_t        amitk_data_set_get_midpt_time       (const AmitkDataSet *ds,
                                                         const guint frame);
amide_data_t        amitk_data_set_get_min              (AmitkDataSet *ds,
                                                         const amide_time_t start,
                                                         const amide_time_t duration);
amide_time_t        amitk_data_set_get_min_frame_duration
                                                        (const AmitkDataSet *ds);
void                amitk_data_set_get_projections      (AmitkDataSet *ds,
                                                         const guint frame,
                                                         const guint gate,
                                                         AmitkDataSet **projections,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);
amide_data_t        amitk_data_set_get_scaling_factor   (const AmitkDataSet *ds,
                                                         const AmitkVoxel i);
amide_data_t        amitk_data_set_get_scaling_intercept
                                                        (const AmitkDataSet *ds,
                                                         const AmitkVoxel i);
AmitkDataSet *      amitk_data_set_get_slice            (AmitkDataSet *ds,
                                                         const amide_time_t start,
                                                         const amide_time_t duration,
                                                         const amide_intpoint_t gate,
                                                         const AmitkCanvasPoint pixel_size,
                                                         const AmitkVolume *slice_volume);
amide_time_t        amitk_data_set_get_start_time       (const AmitkDataSet *ds,
                                                         const guint frame);
void                amitk_data_set_get_thresholding_min_max
                                                        (AmitkDataSet *ds,
                                                         AmitkDataSet *slice,
                                                         const amide_time_t start,
                                                         const amide_time_t duration,
                                                         amide_data_t *min,
                                                         amide_data_t *max);
amide_data_t        amitk_data_set_get_value            (const AmitkDataSet *ds,
                                                         const AmitkVoxel i);
GList *             amitk_data_set_import_file          (AmitkImportMethod method,
                                                         int submethod,
                                                         const gchar *filename,
                                                         gchar **pstudyname,
                                                         AmitkPreferences *preferences,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);
AmitkDataSet *      amitk_data_set_import_raw_file      (const gchar *file_name,
                                                         const AmitkRawFormat raw_format,
                                                         const AmitkVoxel data_dim,
                                                         guint file_offset,
                                                         AmitkPreferences *preferences,
                                                         const AmitkModality modality,
                                                         const gchar *data_set_name,
                                                         const AmitkPoint voxel_size,
                                                         const amide_data_t scale_factor,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);
AmitkDataSet *      amitk_data_set_new                  (AmitkPreferences *preferences,
                                                         const AmitkModality modality);
AmitkDataSet *      amitk_data_set_new_with_data        (AmitkPreferences *preferences,
                                                         const AmitkModality modality,
                                                         const AmitkFormat format,
                                                         const AmitkVoxel dim,
                                                         const AmitkScalingType scaling_type);
void                amitk_data_set_set_color_table      (AmitkDataSet *ds,
                                                         const AmitkViewMode view_mode,
                                                         const AmitkColorTable new_color_table);
void                amitk_data_set_set_color_table_independent
                                                        (AmitkDataSet *ds,
                                                         const AmitkViewMode view_mode,
                                                         const gboolean independent);
void                amitk_data_set_set_conversion       (AmitkDataSet *ds,
                                                         AmitkConversion new_conversion);
void                amitk_data_set_set_cylinder_factor  (AmitkDataSet *ds,
                                                         amide_data_t new_cylinder_factor);
void                amitk_data_set_set_dicom_image_type (AmitkDataSet *ds,
                                                         const gchar *image_type);
void                amitk_data_set_set_diffusion_b_value
                                                        (AmitkDataSet *ds,
                                                         gdouble b_value);
void                amitk_data_set_set_diffusion_direction
                                                        (AmitkDataSet *ds,
                                                         AmitkPoint direction);
void                amitk_data_set_set_displayed_cylinder_unit
                                                        (AmitkDataSet *ds,
                                                         AmitkCylinderUnit new_cylinder_unit);
void                amitk_data_set_set_displayed_dose_unit
                                                        (AmitkDataSet *ds,
                                                         AmitkDoseUnit new_dose_unit);
void                amitk_data_set_set_displayed_weight_unit
                                                        (AmitkDataSet *ds,
                                                         AmitkWeightUnit new_weight_unit);
void                amitk_data_set_set_echo_time        (AmitkDataSet *ds,
                                                         amide_time_t new_echo_time);
void                amitk_data_set_set_frame_duration   (AmitkDataSet *ds,
                                                         const guint frame,
                                                         amide_time_t duration);
void                amitk_data_set_set_gate_time        (AmitkDataSet *ds,
                                                         const guint gate,
                                                         amide_time_t time);
void                amitk_data_set_set_injected_dose    (AmitkDataSet *ds,
                                                         amide_data_t new_injected_dose);
void                amitk_data_set_set_internal_value   (AmitkDataSet *ds,
                                                         const AmitkVoxel i,
                                                         const amide_data_t internal_value,
                                                         const gboolean signal_change);
void                amitk_data_set_set_interpolation    (AmitkDataSet *ds,
                                                         const AmitkInterpolation new_interpolation);
void                amitk_data_set_set_inversion_time   (AmitkDataSet *ds,
                                                         amide_time_t new_inversion_time);
void                amitk_data_set_set_modality         (AmitkDataSet *ds,
                                                         const AmitkModality modality);
void                amitk_data_set_set_rendering        (AmitkDataSet *ds,
                                                         const AmitkRendering new_rendering);
void                amitk_data_set_set_scale_factor     (AmitkDataSet *ds,
                                                         amide_data_t new_scale_factor);
void                amitk_data_set_set_scan_date        (AmitkDataSet *ds,
                                                         const gchar *new_date);
void                amitk_data_set_set_scan_start       (AmitkDataSet *ds,
                                                         const amide_time_t start);
void                amitk_data_set_set_series_number    (AmitkDataSet *ds,
                                                         const gint new_series_number);
void                amitk_data_set_set_subject_dob      (AmitkDataSet *ds,
                                                         const gchar *new_dob);
void                amitk_data_set_set_subject_id       (AmitkDataSet *ds,
                                                         const gchar *new_id);
void                amitk_data_set_set_subject_name     (AmitkDataSet *ds,
                                                         const gchar *new_name);
void                amitk_data_set_set_subject_orientation
                                                        (AmitkDataSet *ds,
                                                         const AmitkSubjectOrientation subject_orientation);
void                amitk_data_set_set_subject_sex      (AmitkDataSet *ds,
                                                         const AmitkSubjectSex subject_sex);
void                amitk_data_set_set_subject_weight   (AmitkDataSet *ds,
                                                         amide_data_t new_subject_weight);
void                amitk_data_set_set_threshold_max    (AmitkDataSet *ds,
                                                         guint which_reference,
                                                         amide_data_t value);
void                amitk_data_set_set_threshold_min    (AmitkDataSet *ds,
                                                         guint which_reference,
                                                         amide_data_t value);
void                amitk_data_set_set_threshold_ref_frame
                                                        (AmitkDataSet *ds,
                                                         guint which_reference,
                                                         guint frame);
void                amitk_data_set_set_threshold_style  (AmitkDataSet *ds,
                                                         const AmitkThresholdStyle threshold_style);
void                amitk_data_set_set_threshold_window (AmitkDataSet *ds,
                                                         const AmitkWindow window,
                                                         const AmitkLimit limit,
                                                         const amide_data_t value);
void                amitk_data_set_set_thresholding     (AmitkDataSet *ds,
                                                         const AmitkThresholding thresholding);
void                amitk_data_set_set_value            (AmitkDataSet *ds,
                                                         const AmitkVoxel i,
                                                         const amide_data_t value,
                                                         const gboolean signal_change);
void                amitk_data_set_set_view_end_gate    (AmitkDataSet *ds,
                                                         amide_intpoint_t end_gate);
void                amitk_data_set_set_view_start_gate  (AmitkDataSet *ds,
                                                         amide_intpoint_t start_gate);
void                amitk_data_set_set_voxel_size       (AmitkDataSet *ds,
                                                         const AmitkPoint voxel_size);
void                amitk_data_set_slice_calc_min_max   (AmitkDataSet *ds,
                                                         const amide_intpoint_t frame,
                                                         const amide_intpoint_t gate,
                                                         const amide_intpoint_t z,
                                                         amitk_format_DOUBLE_t *pmin,
                                                         amitk_format_DOUBLE_t *pmax);
gint                amitk_data_sets_count               (GList *objects,
                                                         gboolean recurse);
gboolean            amitk_data_sets_export_to_file      (GList *data_sets,
                                                         const AmitkExportMethod method,
                                                         const int submethod,
                                                         const gchar *filename,
                                                         const gchar *studyname,
                                                         const AmitkPoint voxel_size,
                                                         const AmitkVolume *bounding_box,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);
AmitkDataSet *      amitk_data_sets_find_with_slice_parent
                                                        (GList *slices,
                                                         const AmitkDataSet *slice_parent);
amide_real_t        amitk_data_sets_get_max_min_voxel_size
                                                        (GList *objects);
amide_time_t        amitk_data_sets_get_min_frame_duration
                                                        (GList *objects);
amide_real_t        amitk_data_sets_get_min_voxel_size  (GList *objects);
GList *             amitk_data_sets_get_slices          (GList *objects,
                                                         GList **pslice_cache,
                                                         const gint max_slice_cache_size,
                                                         const amide_time_t start,
                                                         const amide_time_t duration,
                                                         const amide_intpoint_t gate,
                                                         const AmitkCanvasPoint pixel_size,
                                                         const AmitkVolume *view_volume);
AmitkDataSet *      amitk_data_sets_math_binary         (AmitkDataSet *ds1,
                                                         AmitkDataSet *ds2,
                                                         AmitkOperationBinary operation,
                                                         amide_data_t parameter0,
                                                         gboolean by_frame,
                                                         gboolean maintain_ds1_dim,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);
AmitkDataSet *      amitk_data_sets_math_unary          (AmitkDataSet *ds1,
                                                         AmitkOperationUnary operation,
                                                         amide_data_t parameter0,
                                                         amide_data_t parameter1,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);
GList *             amitk_data_sets_remove_with_slice_parent
                                                        (GList *slices,
                                                         const AmitkDataSet *slice_parent);
amide_data_t        amitk_dose_unit_convert_from        (const amide_data_t dose,
                                                         const AmitkDoseUnit dose_unit);
amide_data_t        amitk_dose_unit_convert_to          (const amide_data_t MBq,
                                                         const AmitkDoseUnit dose_unit);
const gchar *       amitk_dose_unit_get_name            (const AmitkDoseUnit dose_unit);
const gchar *       amitk_interpolation_get_name        (const AmitkInterpolation interpolation);
const gchar *       amitk_operation_binary_get_name     (const AmitkOperationBinary operation);
const gchar *       amitk_operation_unary_get_name      (const AmitkOperationUnary operation);
extern const gchar * amitk_rendering_explanation;
const gchar *       amitk_rendering_get_name            (const AmitkRendering rendering);
const gchar *       amitk_scaling_type_get_name         (const AmitkScalingType scaling_type);
const gchar *       amitk_subject_orientation_get_name  (const AmitkSubjectOrientation subject_orientation);
const gchar *       amitk_subject_sex_get_name          (const AmitkSubjectSex subject_sex);
const gchar *       amitk_threshold_style_get_name      (const AmitkThresholdStyle threshold_style);
const gchar *       amitk_thresholding_get_name         (const AmitkThresholding thresholding);
amide_data_t        amitk_weight_unit_convert_from      (const amide_data_t weight,
                                                         const AmitkWeightUnit weight_unit);
amide_data_t        amitk_weight_unit_convert_to        (const amide_data_t kg,
                                                         const AmitkWeightUnit weight_unit);
const gchar *       amitk_weight_unit_get_name          (const AmitkWeightUnit weight_unit);

Object Hierarchy

  GEnum
   +----AmitkConversion
  GEnum
   +----AmitkCylinderUnit
  GObject
   +----AmitkSpace
         +----AmitkObject
               +----AmitkVolume
                     +----AmitkDataSet
  GEnum
   +----AmitkDoseUnit
  GEnum
   +----AmitkInterpolation
  GEnum
   +----AmitkOperationBinary
  GEnum
   +----AmitkOperationUnary
  GEnum
   +----AmitkRendering
  GEnum
   +----AmitkScalingType
  GEnum
   +----AmitkSubjectOrientation
  GEnum
   +----AmitkSubjectSex
  GEnum
   +----AmitkThresholding
  GEnum
   +----AmitkWeightUnit

Signals

  "color-table-changed"                            : Run Last
  "color-table-independent-changed"                : Run Last
  "conversion-changed"                             : Run Last
  "data-set-changed"                               : Run Last
  "interpolation-changed"                          : Run Last
  "invalidate-slice-cache"                         : Run Last
  "modality-changed"                               : Run Last
  "rendering-changed"                              : Run Last
  "scale-factor-changed"                           : Run Last
  "subject-orientation-changed"                    : Run Last
  "subject-sex-changed"                            : Run Last
  "threshold-style-changed"                        : Run Last
  "thresholding-changed"                           : Run Last
  "thresholds-changed"                             : Run Last
  "time-changed"                                   : Run Last
  "view-gates-changed"                             : Run Last
  "voxel-size-changed"                             : Run Last
  "windows-changed"                                : Run Last

Description

Details

AMITK_DATA_SET_COLOR_TABLE()

#define AMITK_DATA_SET_COLOR_TABLE(ds, view_mode)  (AMITK_DATA_SET(ds)->color_table[view_mode])


AMITK_DATA_SET_COLOR_TABLE_INDEPENDENT()

#define AMITK_DATA_SET_COLOR_TABLE_INDEPENDENT(ds, view_mode) (AMITK_DATA_SET(ds)->color_table_independent[view_mode])


AMITK_DATA_SET_CONVERSION()

#define AMITK_DATA_SET_CONVERSION(ds)              (AMITK_DATA_SET(ds)->conversion)


AMITK_DATA_SET_CYLINDER_FACTOR()

#define AMITK_DATA_SET_CYLINDER_FACTOR(ds)         (AMITK_DATA_SET(ds)->cylinder_factor)


AMITK_DATA_SET_DICOM_IMAGE_TYPE()

#define AMITK_DATA_SET_DICOM_IMAGE_TYPE(ds)        (AMITK_DATA_SET(ds)->dicom_image_type)


AMITK_DATA_SET_DIFFUSION_B_VALUE()

#define AMITK_DATA_SET_DIFFUSION_B_VALUE(ds)       (AMITK_DATA_SET(ds)->diffusion_b_value)


AMITK_DATA_SET_DIFFUSION_DIRECTION()

#define AMITK_DATA_SET_DIFFUSION_DIRECTION(ds)     (AMITK_DATA_SET(ds)->diffusion_direction)


AMITK_DATA_SET_DIM()

#define AMITK_DATA_SET_DIM(ds)                     (AMITK_RAW_DATA_DIM(AMITK_DATA_SET_RAW_DATA(ds)))


AMITK_DATA_SET_DIM_G()

#define AMITK_DATA_SET_DIM_G(ds)                   (AMITK_RAW_DATA_DIM_G(AMITK_DATA_SET_RAW_DATA(ds)))


AMITK_DATA_SET_DIM_T()

#define AMITK_DATA_SET_DIM_T(ds)                   (AMITK_RAW_DATA_DIM_T(AMITK_DATA_SET_RAW_DATA(ds)))


AMITK_DATA_SET_DIM_X()

#define AMITK_DATA_SET_DIM_X(ds)                   (AMITK_RAW_DATA_DIM_X(AMITK_DATA_SET_RAW_DATA(ds)))


AMITK_DATA_SET_DIM_Y()

#define AMITK_DATA_SET_DIM_Y(ds)                   (AMITK_RAW_DATA_DIM_Y(AMITK_DATA_SET_RAW_DATA(ds)))


AMITK_DATA_SET_DIM_Z()

#define AMITK_DATA_SET_DIM_Z(ds)                   (AMITK_RAW_DATA_DIM_Z(AMITK_DATA_SET_RAW_DATA(ds)))


AMITK_DATA_SET_DISPLAYED_CYLINDER_UNIT()

#define AMITK_DATA_SET_DISPLAYED_CYLINDER_UNIT(ds) (AMITK_DATA_SET(ds)->displayed_cylinder_unit)


AMITK_DATA_SET_DISPLAYED_DOSE_UNIT()

#define AMITK_DATA_SET_DISPLAYED_DOSE_UNIT(ds)     (AMITK_DATA_SET(ds)->displayed_dose_unit)


AMITK_DATA_SET_DISPLAYED_WEIGHT_UNIT()

#define AMITK_DATA_SET_DISPLAYED_WEIGHT_UNIT(ds)   (AMITK_DATA_SET(ds)->displayed_weight_unit)


AMITK_DATA_SET_DISTRIBUTION()

#define AMITK_DATA_SET_DISTRIBUTION(ds)            (AMITK_DATA_SET(ds)->distribution)


AMITK_DATA_SET_DISTRIBUTION_SIZE

#define AMITK_DATA_SET_DISTRIBUTION_SIZE 256


AMITK_DATA_SET_DYNAMIC()

#define AMITK_DATA_SET_DYNAMIC(ds)                 (AMITK_DATA_SET_NUM_FRAMES(ds) > 1)


AMITK_DATA_SET_ECHO_TIME()

#define AMITK_DATA_SET_ECHO_TIME(ds)               (AMITK_DATA_SET(ds)->echo_time)


AMITK_DATA_SET_FORMAT()

#define AMITK_DATA_SET_FORMAT(ds)                  (AMITK_RAW_DATA_FORMAT(AMITK_DATA_SET_RAW_DATA(ds)))


AMITK_DATA_SET_GATED()

#define AMITK_DATA_SET_GATED(ds)                   (AMITK_DATA_SET_NUM_GATES(ds) > 1)


AMITK_DATA_SET_INJECTED_DOSE()

#define AMITK_DATA_SET_INJECTED_DOSE(ds)           (AMITK_DATA_SET(ds)->injected_dose)


AMITK_DATA_SET_INTERPOLATION()

#define AMITK_DATA_SET_INTERPOLATION(ds)           (AMITK_DATA_SET(ds)->interpolation)


AMITK_DATA_SET_INVERSION_TIME()

#define AMITK_DATA_SET_INVERSION_TIME(ds)          (AMITK_DATA_SET(ds)->inversion_time)


AMITK_DATA_SET_MODALITY()

#define AMITK_DATA_SET_MODALITY(ds)                (AMITK_DATA_SET(ds)->modality)


AMITK_DATA_SET_NUM_FRAMES()

#define AMITK_DATA_SET_NUM_FRAMES(ds)              (AMITK_DATA_SET_DIM_T(ds))


AMITK_DATA_SET_NUM_GATES()

#define AMITK_DATA_SET_NUM_GATES(ds)               (AMITK_DATA_SET_DIM_G(ds))


AMITK_DATA_SET_NUM_VIEW_GATES()

#define AMITK_DATA_SET_NUM_VIEW_GATES(ds)          (AMITK_DATA_SET(ds)->num_view_gates)


AMITK_DATA_SET_RAW_DATA()

#define AMITK_DATA_SET_RAW_DATA(ds)                (AMITK_DATA_SET(ds)->raw_data)


AMITK_DATA_SET_RENDERING()

#define AMITK_DATA_SET_RENDERING(ds)               (AMITK_DATA_SET(ds)->rendering)


AMITK_DATA_SET_SCALE_FACTOR()

#define AMITK_DATA_SET_SCALE_FACTOR(ds)            (AMITK_DATA_SET(ds)->scale_factor)


AMITK_DATA_SET_SCALING_HAS_INTERCEPT()

#define AMITK_DATA_SET_SCALING_HAS_INTERCEPT(ds)   ((AMITK_DATA_SET(ds)->scaling_type == AMITK_SCALING_TYPE_0D_WITH_INTERCEPT) || (AMITK_DATA_SET(ds)->scaling_type == AMITK_SCALING_TYPE_1D_WITH_INTERCEPT) || (AMITK_DATA_SET(ds)->scaling_type == AMITK_SCALING_TYPE_2D_WITH_INTERCEPT)) 


AMITK_DATA_SET_SCALING_TYPE()

#define AMITK_DATA_SET_SCALING_TYPE(ds)            (AMITK_DATA_SET(ds)->scaling_type)


AMITK_DATA_SET_SCAN_DATE()

#define AMITK_DATA_SET_SCAN_DATE(ds)               (AMITK_DATA_SET(ds)->scan_date)


AMITK_DATA_SET_SCAN_START()

#define AMITK_DATA_SET_SCAN_START(ds)              (AMITK_DATA_SET(ds)->scan_start)


AMITK_DATA_SET_SERIES_NUMBER()

#define AMITK_DATA_SET_SERIES_NUMBER(ds)           (AMITK_DATA_SET(ds)->series_number)


AMITK_DATA_SET_SLICE_PARENT()

#define AMITK_DATA_SET_SLICE_PARENT(ds)            (AMITK_DATA_SET(ds)->slice_parent)


AMITK_DATA_SET_SUBJECT_DOB()

#define AMITK_DATA_SET_SUBJECT_DOB(ds)             (AMITK_DATA_SET(ds)->subject_dob)


AMITK_DATA_SET_SUBJECT_ID()

#define AMITK_DATA_SET_SUBJECT_ID(ds)              (AMITK_DATA_SET(ds)->subject_id)


AMITK_DATA_SET_SUBJECT_NAME()

#define AMITK_DATA_SET_SUBJECT_NAME(ds)            (AMITK_DATA_SET(ds)->subject_name)


AMITK_DATA_SET_SUBJECT_ORIENTATION()

#define AMITK_DATA_SET_SUBJECT_ORIENTATION(ds)     (AMITK_DATA_SET(ds)->subject_orientation)


AMITK_DATA_SET_SUBJECT_SEX()

#define AMITK_DATA_SET_SUBJECT_SEX(ds)             (AMITK_DATA_SET(ds)->subject_sex)


AMITK_DATA_SET_SUBJECT_WEIGHT()

#define AMITK_DATA_SET_SUBJECT_WEIGHT(ds)          (AMITK_DATA_SET(ds)->subject_weight)


AMITK_DATA_SET_THRESHOLDING()

#define AMITK_DATA_SET_THRESHOLDING(ds)            (AMITK_DATA_SET(ds)->thresholding)


AMITK_DATA_SET_THRESHOLD_MAX()

#define AMITK_DATA_SET_THRESHOLD_MAX(ds, ref_frame)      (AMITK_DATA_SET(ds)->threshold_max[ref_frame])


AMITK_DATA_SET_THRESHOLD_MIN()

#define AMITK_DATA_SET_THRESHOLD_MIN(ds, ref_frame)      (AMITK_DATA_SET(ds)->threshold_min[ref_frame])


AMITK_DATA_SET_THRESHOLD_REF_FRAME()

#define AMITK_DATA_SET_THRESHOLD_REF_FRAME(ds,ref_frame) (AMITK_DATA_SET(ds)->threshold_ref_frame[ref_frame])


AMITK_DATA_SET_THRESHOLD_STYLE()

#define AMITK_DATA_SET_THRESHOLD_STYLE(ds)         (AMITK_DATA_SET(ds)->threshold_style)


AMITK_DATA_SET_THRESHOLD_WINDOW()

#define AMITK_DATA_SET_THRESHOLD_WINDOW(ds, i_win, limit) (AMITK_DATA_SET(ds)->threshold_window[i_win][limit])


AMITK_DATA_SET_TOTAL_PLANES()

#define AMITK_DATA_SET_TOTAL_PLANES(ds)            (AMITK_DATA_SET_DIM_Z(ds)*AMITK_DATA_SET_DIM_G(ds)*AMITK_DATA_SET_DIM_T(ds))


AMITK_DATA_SET_VIEW_END_GATE()

#define AMITK_DATA_SET_VIEW_END_GATE(ds)           (AMITK_DATA_SET(ds)->view_end_gate)


AMITK_DATA_SET_VIEW_START_GATE()

#define AMITK_DATA_SET_VIEW_START_GATE(ds)         (AMITK_DATA_SET(ds)->view_start_gate)


AMITK_DATA_SET_VOXEL_SIZE()

#define AMITK_DATA_SET_VOXEL_SIZE(ds)              (AMITK_DATA_SET(ds)->voxel_size)


AMITK_DATA_SET_VOXEL_SIZE_X()

#define AMITK_DATA_SET_VOXEL_SIZE_X(ds)            (AMITK_DATA_SET(ds)->voxel_size.x)


AMITK_DATA_SET_VOXEL_SIZE_Y()

#define AMITK_DATA_SET_VOXEL_SIZE_Y(ds)            (AMITK_DATA_SET(ds)->voxel_size.y)


AMITK_DATA_SET_VOXEL_SIZE_Z()

#define AMITK_DATA_SET_VOXEL_SIZE_Z(ds)            (AMITK_DATA_SET(ds)->voxel_size.z)


AMITK_DATA_SET_VOXEL_VOLUME()

#define AMITK_DATA_SET_VOXEL_VOLUME(ds)            (AMITK_DATA_SET(ds)->voxel_size.z*AMITK_DATA_SET(ds)->voxel_size.y*AMITK_DATA_SET(ds)->voxel_size.x)


enum AmitkConversion

typedef enum {
  AMITK_CONVERSION_STRAIGHT,
  AMITK_CONVERSION_PERCENT_ID_PER_CC,
  AMITK_CONVERSION_SUV,
  AMITK_CONVERSION_NUM
} AmitkConversion;


enum AmitkCylinderUnit

typedef enum {
  AMITK_CYLINDER_UNIT_MEGABECQUEREL_PER_CC_IMAGE_UNIT,
  AMITK_CYLINDER_UNIT_MILLICURIE_PER_CC_IMAGE_UNIT,
  AMITK_CYLINDER_UNIT_MICROCURIE_PER_CC_IMAGE_UNIT,
  AMITK_CYLINDER_UNIT_NANOCURIE_PER_CC_IMAGE_UNIT,
  AMITK_CYLINDER_UNIT_IMAGE_UNIT_CC_PER_MEGABECQUEREL,
  AMITK_CYLINDER_UNIT_IMAGE_UNIT_CC_PER_MILLICURIE,
  AMITK_CYLINDER_UNIT_IMAGE_UNIT_CC_PER_MICROCURIE,
  AMITK_CYLINDER_UNIT_IMAGE_UNIT_CC_PER_NANOCURIE,
  AMITK_CYLINDER_UNIT_NUM
} AmitkCylinderUnit;


struct AmitkDataSet

struct AmitkDataSet;


struct AmitkDataSetClass

struct AmitkDataSetClass {
  AmitkVolumeClass parent_class;

  void (* thresholding_changed)         (AmitkDataSet * ds);
  void (* threshold_style_changed)      (AmitkDataSet * ds);
  void (* thresholds_changed)           (AmitkDataSet * ds);
  void (* windows_changed)              (AmitkDataSet * ds);
  void (* color_table_changed)          (AmitkDataSet * ds,
					 AmitkViewMode * view_mode);
  void (* color_table_independent_changed)(AmitkDataSet * ds,
					   AmitkViewMode * view_mode);
  void (* interpolation_changed)        (AmitkDataSet * ds);
  void (* rendering_changed)            (AmitkDataSet * ds);
  void (* subject_orientation_changed)  (AmitkDataSet * ds);
  void (* subject_sex_changed)          (AmitkDataSet * ds);
  void (* conversion_changed)           (AmitkDataSet * ds);
  void (* scale_factor_changed)         (AmitkDataSet * ds);
  void (* modality_changed)             (AmitkDataSet * ds);
  void (* time_changed)                 (AmitkDataSet * ds);
  void (* voxel_size_changed)           (AmitkDataSet * ds);
  void (* data_set_changed)             (AmitkDataSet * ds);
  void (* invalidate_slice_cache)       (AmitkDataSet * ds);
  void (* view_gates_changed)           (AmitkDataSet * ds);
};


enum AmitkDoseUnit

typedef enum {
  AMITK_DOSE_UNIT_MEGABECQUEREL,
  AMITK_DOSE_UNIT_MILLICURIE,
  AMITK_DOSE_UNIT_MICROCURIE,
  AMITK_DOSE_UNIT_NANOCURIE,
  AMITK_DOSE_UNIT_NUM
} AmitkDoseUnit;


enum AmitkExportMethod

typedef enum {
 /*< skip >*/
  AMITK_EXPORT_METHOD_RAW, 
#ifdef AMIDE_LIBDCMDATA_SUPPORT
  AMITK_EXPORT_METHOD_DCMTK,
#endif
#ifdef AMIDE_LIBMDC_SUPPORT
  AMITK_EXPORT_METHOD_LIBMDC,
#endif
  AMITK_EXPORT_METHOD_NUM
} AmitkExportMethod;


enum AmitkImportMethod

typedef enum {
 /*< skip >*/
  AMITK_IMPORT_METHOD_GUESS, 
  AMITK_IMPORT_METHOD_RAW, 
#ifdef AMIDE_LIBDCMDATA_SUPPORT
  AMITK_IMPORT_METHOD_DCMTK,
#endif
#ifdef AMIDE_LIBECAT_SUPPORT
  AMITK_IMPORT_METHOD_LIBECAT,
#endif
#ifdef AMIDE_LIBMDC_SUPPORT
  AMITK_IMPORT_METHOD_LIBMDC,
#endif
  AMITK_IMPORT_METHOD_NUM
} AmitkImportMethod;


enum AmitkInterpolation

typedef enum {
  AMITK_INTERPOLATION_NEAREST_NEIGHBOR, 
  AMITK_INTERPOLATION_TRILINEAR, 
  AMITK_INTERPOLATION_NUM
} AmitkInterpolation;


enum AmitkOperationBinary

typedef enum {
  AMITK_OPERATION_BINARY_ADD,
  AMITK_OPERATION_BINARY_SUB,
  AMITK_OPERATION_BINARY_MULTIPLY,
  AMITK_OPERATION_BINARY_DIVISION,
  AMITK_OPERATION_BINARY_NUM
} AmitkOperationBinary;


enum AmitkOperationUnary

typedef enum {
  AMITK_OPERATION_UNARY_THRESHOLD,
  AMITK_OPERATION_UNARY_NUM
} AmitkOperationUnary;


enum AmitkRendering

typedef enum {
  AMITK_RENDERING_MPR,
  AMITK_RENDERING_MIP,
  AMITK_RENDERING_MINIP,
  AMITK_RENDERING_NUM
} AmitkRendering;


enum AmitkScalingType

typedef enum {
  AMITK_SCALING_TYPE_0D,
  AMITK_SCALING_TYPE_1D,
  AMITK_SCALING_TYPE_2D,
  AMITK_SCALING_TYPE_0D_WITH_INTERCEPT,
  AMITK_SCALING_TYPE_1D_WITH_INTERCEPT,
  AMITK_SCALING_TYPE_2D_WITH_INTERCEPT,
  AMITK_SCALING_TYPE_NUM
} AmitkScalingType;


enum AmitkSubjectOrientation

typedef enum {
  AMITK_SUBJECT_ORIENTATION_UNKNOWN,
  AMITK_SUBJECT_ORIENTATION_SUPINE_HEADFIRST,
  AMITK_SUBJECT_ORIENTATION_SUPINE_FEETFIRST,
  AMITK_SUBJECT_ORIENTATION_PRONE_HEADFIRST,
  AMITK_SUBJECT_ORIENTATION_PRONE_FEETFIRST,
  AMITK_SUBJECT_ORIENTATION_RIGHT_DECUBITUS_HEADFIRST,
  AMITK_SUBJECT_ORIENTATION_RIGHT_DECUBITUS_FEETFIRST,
  AMITK_SUBJECT_ORIENTATION_LEFT_DECUBITUS_HEADFIRST,
  AMITK_SUBJECT_ORIENTATION_LEFT_DECUBITUS_FEETFIRST,
  AMITK_SUBJECT_ORIENTATION_NUM
} AmitkSubjectOrientation;


enum AmitkSubjectSex

typedef enum {
  AMITK_SUBJECT_SEX_UNKNOWN,
  AMITK_SUBJECT_SEX_MALE,
  AMITK_SUBJECT_SEX_FEMALE,
  AMITK_SUBJECT_SEX_NUM
} AmitkSubjectSex;


enum AmitkThresholding

typedef enum {
  AMITK_THRESHOLDING_PER_SLICE, 
  AMITK_THRESHOLDING_PER_FRAME, 
  AMITK_THRESHOLDING_INTERPOLATE_FRAMES,
  AMITK_THRESHOLDING_GLOBAL, 
  AMITK_THRESHOLDING_NUM
} AmitkThresholding;


enum AmitkWeightUnit

typedef enum {
  AMITK_WEIGHT_UNIT_KILOGRAM,
  AMITK_WEIGHT_UNIT_GRAM,
  AMITK_WEIGHT_UNIT_POUND,
  AMITK_WEIGHT_UNIT_OUNCE,
  AMITK_WEIGHT_UNIT_NUM
} AmitkWeightUnit;


amitk_conversion_get_name ()

const gchar *       amitk_conversion_get_name           (const AmitkConversion conversion);


amitk_cylinder_unit_convert_from ()

amide_data_t        amitk_cylinder_unit_convert_from    (const amide_data_t cylinder_factor,
                                                         const AmitkCylinderUnit cylinder_unit);


amitk_cylinder_unit_convert_to ()

amide_data_t        amitk_cylinder_unit_convert_to      (const amide_data_t MBq_cc_image_units,
                                                         const AmitkCylinderUnit cylinder_unit);


amitk_cylinder_unit_get_name ()

const gchar *       amitk_cylinder_unit_get_name        (const AmitkCylinderUnit cylinder_unit);


amitk_data_set_calc_distribution ()

void                amitk_data_set_calc_distribution    (AmitkDataSet *ds,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);


amitk_data_set_calc_far_corner ()

void                amitk_data_set_calc_far_corner      (AmitkDataSet *ds);


amitk_data_set_calc_min_max ()

void                amitk_data_set_calc_min_max         (AmitkDataSet *ds,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);


amitk_data_set_calc_min_max_if_needed ()

void                amitk_data_set_calc_min_max_if_needed
                                                        (AmitkDataSet *ds,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);


amitk_data_set_export_to_file ()

gboolean            amitk_data_set_export_to_file       (AmitkDataSet *ds,
                                                         const AmitkExportMethod method,
                                                         const int submethod,
                                                         const gchar *filename,
                                                         const gchar *studyname,
                                                         const gboolean resliced,
                                                         const AmitkPoint voxel_size,
                                                         const AmitkVolume *bounding_box,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);


amitk_data_set_get_color_table_to_use ()

AmitkColorTable     amitk_data_set_get_color_table_to_use
                                                        (AmitkDataSet *ds,
                                                         const AmitkViewMode view_mode);


amitk_data_set_get_cropped ()

AmitkDataSet *      amitk_data_set_get_cropped          (const AmitkDataSet *ds,
                                                         const AmitkVoxel start,
                                                         const AmitkVoxel end,
                                                         const AmitkFormat format,
                                                         const AmitkScalingType scaling_type,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);


amitk_data_set_get_end_time ()

amide_time_t        amitk_data_set_get_end_time         (const AmitkDataSet *ds,
                                                         const guint frame);


amitk_data_set_get_filtered ()

AmitkDataSet *      amitk_data_set_get_filtered         (const AmitkDataSet *ds,
                                                         const AmitkFilter filter_type,
                                                         const gint kernel_size,
                                                         const amide_real_t fwhm,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);


amitk_data_set_get_frame ()

guint               amitk_data_set_get_frame            (const AmitkDataSet *ds,
                                                         const amide_time_t time);


amitk_data_set_get_frame_duration ()

amide_time_t        amitk_data_set_get_frame_duration   (const AmitkDataSet *ds,
                                                         guint frame);


amitk_data_set_get_frame_duration_mem()

#define amitk_data_set_get_frame_duration_mem(ds) (g_try_new0(amide_time_t,(ds)->raw_data->dim.t))


amitk_data_set_get_frame_max ()

amide_data_t        amitk_data_set_get_frame_max        (AmitkDataSet *ds,
                                                         const guint frame);


amitk_data_set_get_frame_min ()

amide_data_t        amitk_data_set_get_frame_min        (AmitkDataSet *ds,
                                                         const guint frame);


amitk_data_set_get_frame_min_max_mem()

#define amitk_data_set_get_frame_min_max_mem(ds) (g_try_new0(amide_data_t,(ds)->raw_data->dim.t))


amitk_data_set_get_gate_time ()

amide_time_t        amitk_data_set_get_gate_time        (const AmitkDataSet *ds,
                                                         const guint gate);


amitk_data_set_get_gate_time_mem()

#define amitk_data_set_get_gate_time_mem(ds) (g_try_new0(amide_time_t,(ds)->raw_data->dim.g))


amitk_data_set_get_global_max ()

amide_data_t        amitk_data_set_get_global_max       (AmitkDataSet *ds);


amitk_data_set_get_global_min ()

amide_data_t        amitk_data_set_get_global_min       (AmitkDataSet *ds);


amitk_data_set_get_internal_scaling_factor ()

amide_data_t        amitk_data_set_get_internal_scaling_factor
                                                        (const AmitkDataSet *ds,
                                                         const AmitkVoxel i);


amitk_data_set_get_internal_value ()

amide_data_t        amitk_data_set_get_internal_value   (const AmitkDataSet *ds,
                                                         const AmitkVoxel i);


amitk_data_set_get_line_profile ()

void                amitk_data_set_get_line_profile     (AmitkDataSet *ds,
                                                         const amide_time_t start,
                                                         const amide_time_t duration,
                                                         const AmitkPoint start_point,
                                                         const AmitkPoint end_point,
                                                         GPtrArray **preturn_data);


amitk_data_set_get_max ()

amide_data_t        amitk_data_set_get_max              (AmitkDataSet *ds,
                                                         const amide_time_t start,
                                                         const amide_time_t duration);


amitk_data_set_get_midpt_time ()

amide_time_t        amitk_data_set_get_midpt_time       (const AmitkDataSet *ds,
                                                         const guint frame);


amitk_data_set_get_min ()

amide_data_t        amitk_data_set_get_min              (AmitkDataSet *ds,
                                                         const amide_time_t start,
                                                         const amide_time_t duration);


amitk_data_set_get_min_frame_duration ()

amide_time_t        amitk_data_set_get_min_frame_duration
                                                        (const AmitkDataSet *ds);


amitk_data_set_get_projections ()

void                amitk_data_set_get_projections      (AmitkDataSet *ds,
                                                         const guint frame,
                                                         const guint gate,
                                                         AmitkDataSet **projections,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);


amitk_data_set_get_scaling_factor ()

amide_data_t        amitk_data_set_get_scaling_factor   (const AmitkDataSet *ds,
                                                         const AmitkVoxel i);


amitk_data_set_get_scaling_intercept ()

amide_data_t        amitk_data_set_get_scaling_intercept
                                                        (const AmitkDataSet *ds,
                                                         const AmitkVoxel i);


amitk_data_set_get_slice ()

AmitkDataSet *      amitk_data_set_get_slice            (AmitkDataSet *ds,
                                                         const amide_time_t start,
                                                         const amide_time_t duration,
                                                         const amide_intpoint_t gate,
                                                         const AmitkCanvasPoint pixel_size,
                                                         const AmitkVolume *slice_volume);


amitk_data_set_get_start_time ()

amide_time_t        amitk_data_set_get_start_time       (const AmitkDataSet *ds,
                                                         const guint frame);


amitk_data_set_get_thresholding_min_max ()

void                amitk_data_set_get_thresholding_min_max
                                                        (AmitkDataSet *ds,
                                                         AmitkDataSet *slice,
                                                         const amide_time_t start,
                                                         const amide_time_t duration,
                                                         amide_data_t *min,
                                                         amide_data_t *max);


amitk_data_set_get_value ()

amide_data_t        amitk_data_set_get_value            (const AmitkDataSet *ds,
                                                         const AmitkVoxel i);


amitk_data_set_import_file ()

GList *             amitk_data_set_import_file          (AmitkImportMethod method,
                                                         int submethod,
                                                         const gchar *filename,
                                                         gchar **pstudyname,
                                                         AmitkPreferences *preferences,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);


amitk_data_set_import_raw_file ()

AmitkDataSet *      amitk_data_set_import_raw_file      (const gchar *file_name,
                                                         const AmitkRawFormat raw_format,
                                                         const AmitkVoxel data_dim,
                                                         guint file_offset,
                                                         AmitkPreferences *preferences,
                                                         const AmitkModality modality,
                                                         const gchar *data_set_name,
                                                         const AmitkPoint voxel_size,
                                                         const amide_data_t scale_factor,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);


amitk_data_set_new ()

AmitkDataSet *      amitk_data_set_new                  (AmitkPreferences *preferences,
                                                         const AmitkModality modality);


amitk_data_set_new_with_data ()

AmitkDataSet *      amitk_data_set_new_with_data        (AmitkPreferences *preferences,
                                                         const AmitkModality modality,
                                                         const AmitkFormat format,
                                                         const AmitkVoxel dim,
                                                         const AmitkScalingType scaling_type);


amitk_data_set_set_color_table ()

void                amitk_data_set_set_color_table      (AmitkDataSet *ds,
                                                         const AmitkViewMode view_mode,
                                                         const AmitkColorTable new_color_table);


amitk_data_set_set_color_table_independent ()

void                amitk_data_set_set_color_table_independent
                                                        (AmitkDataSet *ds,
                                                         const AmitkViewMode view_mode,
                                                         const gboolean independent);


amitk_data_set_set_conversion ()

void                amitk_data_set_set_conversion       (AmitkDataSet *ds,
                                                         AmitkConversion new_conversion);


amitk_data_set_set_cylinder_factor ()

void                amitk_data_set_set_cylinder_factor  (AmitkDataSet *ds,
                                                         amide_data_t new_cylinder_factor);


amitk_data_set_set_dicom_image_type ()

void                amitk_data_set_set_dicom_image_type (AmitkDataSet *ds,
                                                         const gchar *image_type);


amitk_data_set_set_diffusion_b_value ()

void                amitk_data_set_set_diffusion_b_value
                                                        (AmitkDataSet *ds,
                                                         gdouble b_value);


amitk_data_set_set_diffusion_direction ()

void                amitk_data_set_set_diffusion_direction
                                                        (AmitkDataSet *ds,
                                                         AmitkPoint direction);


amitk_data_set_set_displayed_cylinder_unit ()

void                amitk_data_set_set_displayed_cylinder_unit
                                                        (AmitkDataSet *ds,
                                                         AmitkCylinderUnit new_cylinder_unit);


amitk_data_set_set_displayed_dose_unit ()

void                amitk_data_set_set_displayed_dose_unit
                                                        (AmitkDataSet *ds,
                                                         AmitkDoseUnit new_dose_unit);


amitk_data_set_set_displayed_weight_unit ()

void                amitk_data_set_set_displayed_weight_unit
                                                        (AmitkDataSet *ds,
                                                         AmitkWeightUnit new_weight_unit);


amitk_data_set_set_echo_time ()

void                amitk_data_set_set_echo_time        (AmitkDataSet *ds,
                                                         amide_time_t new_echo_time);


amitk_data_set_set_frame_duration ()

void                amitk_data_set_set_frame_duration   (AmitkDataSet *ds,
                                                         const guint frame,
                                                         amide_time_t duration);


amitk_data_set_set_gate_time ()

void                amitk_data_set_set_gate_time        (AmitkDataSet *ds,
                                                         const guint gate,
                                                         amide_time_t time);


amitk_data_set_set_injected_dose ()

void                amitk_data_set_set_injected_dose    (AmitkDataSet *ds,
                                                         amide_data_t new_injected_dose);


amitk_data_set_set_internal_value ()

void                amitk_data_set_set_internal_value   (AmitkDataSet *ds,
                                                         const AmitkVoxel i,
                                                         const amide_data_t internal_value,
                                                         const gboolean signal_change);


amitk_data_set_set_interpolation ()

void                amitk_data_set_set_interpolation    (AmitkDataSet *ds,
                                                         const AmitkInterpolation new_interpolation);


amitk_data_set_set_inversion_time ()

void                amitk_data_set_set_inversion_time   (AmitkDataSet *ds,
                                                         amide_time_t new_inversion_time);


amitk_data_set_set_modality ()

void                amitk_data_set_set_modality         (AmitkDataSet *ds,
                                                         const AmitkModality modality);


amitk_data_set_set_rendering ()

void                amitk_data_set_set_rendering        (AmitkDataSet *ds,
                                                         const AmitkRendering new_rendering);


amitk_data_set_set_scale_factor ()

void                amitk_data_set_set_scale_factor     (AmitkDataSet *ds,
                                                         amide_data_t new_scale_factor);


amitk_data_set_set_scan_date ()

void                amitk_data_set_set_scan_date        (AmitkDataSet *ds,
                                                         const gchar *new_date);


amitk_data_set_set_scan_start ()

void                amitk_data_set_set_scan_start       (AmitkDataSet *ds,
                                                         const amide_time_t start);


amitk_data_set_set_series_number ()

void                amitk_data_set_set_series_number    (AmitkDataSet *ds,
                                                         const gint new_series_number);


amitk_data_set_set_subject_dob ()

void                amitk_data_set_set_subject_dob      (AmitkDataSet *ds,
                                                         const gchar *new_dob);


amitk_data_set_set_subject_id ()

void                amitk_data_set_set_subject_id       (AmitkDataSet *ds,
                                                         const gchar *new_id);


amitk_data_set_set_subject_name ()

void                amitk_data_set_set_subject_name     (AmitkDataSet *ds,
                                                         const gchar *new_name);


amitk_data_set_set_subject_orientation ()

void                amitk_data_set_set_subject_orientation
                                                        (AmitkDataSet *ds,
                                                         const AmitkSubjectOrientation subject_orientation);


amitk_data_set_set_subject_sex ()

void                amitk_data_set_set_subject_sex      (AmitkDataSet *ds,
                                                         const AmitkSubjectSex subject_sex);


amitk_data_set_set_subject_weight ()

void                amitk_data_set_set_subject_weight   (AmitkDataSet *ds,
                                                         amide_data_t new_subject_weight);


amitk_data_set_set_threshold_max ()

void                amitk_data_set_set_threshold_max    (AmitkDataSet *ds,
                                                         guint which_reference,
                                                         amide_data_t value);


amitk_data_set_set_threshold_min ()

void                amitk_data_set_set_threshold_min    (AmitkDataSet *ds,
                                                         guint which_reference,
                                                         amide_data_t value);


amitk_data_set_set_threshold_ref_frame ()

void                amitk_data_set_set_threshold_ref_frame
                                                        (AmitkDataSet *ds,
                                                         guint which_reference,
                                                         guint frame);


amitk_data_set_set_threshold_style ()

void                amitk_data_set_set_threshold_style  (AmitkDataSet *ds,
                                                         const AmitkThresholdStyle threshold_style);


amitk_data_set_set_threshold_window ()

void                amitk_data_set_set_threshold_window (AmitkDataSet *ds,
                                                         const AmitkWindow window,
                                                         const AmitkLimit limit,
                                                         const amide_data_t value);


amitk_data_set_set_thresholding ()

void                amitk_data_set_set_thresholding     (AmitkDataSet *ds,
                                                         const AmitkThresholding thresholding);


amitk_data_set_set_value ()

void                amitk_data_set_set_value            (AmitkDataSet *ds,
                                                         const AmitkVoxel i,
                                                         const amide_data_t value,
                                                         const gboolean signal_change);


amitk_data_set_set_view_end_gate ()

void                amitk_data_set_set_view_end_gate    (AmitkDataSet *ds,
                                                         amide_intpoint_t end_gate);


amitk_data_set_set_view_start_gate ()

void                amitk_data_set_set_view_start_gate  (AmitkDataSet *ds,
                                                         amide_intpoint_t start_gate);


amitk_data_set_set_voxel_size ()

void                amitk_data_set_set_voxel_size       (AmitkDataSet *ds,
                                                         const AmitkPoint voxel_size);


amitk_data_set_slice_calc_min_max ()

void                amitk_data_set_slice_calc_min_max   (AmitkDataSet *ds,
                                                         const amide_intpoint_t frame,
                                                         const amide_intpoint_t gate,
                                                         const amide_intpoint_t z,
                                                         amitk_format_DOUBLE_t *pmin,
                                                         amitk_format_DOUBLE_t *pmax);


amitk_data_sets_count ()

gint                amitk_data_sets_count               (GList *objects,
                                                         gboolean recurse);


amitk_data_sets_export_to_file ()

gboolean            amitk_data_sets_export_to_file      (GList *data_sets,
                                                         const AmitkExportMethod method,
                                                         const int submethod,
                                                         const gchar *filename,
                                                         const gchar *studyname,
                                                         const AmitkPoint voxel_size,
                                                         const AmitkVolume *bounding_box,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);


amitk_data_sets_find_with_slice_parent ()

AmitkDataSet *      amitk_data_sets_find_with_slice_parent
                                                        (GList *slices,
                                                         const AmitkDataSet *slice_parent);


amitk_data_sets_get_max_min_voxel_size ()

amide_real_t        amitk_data_sets_get_max_min_voxel_size
                                                        (GList *objects);


amitk_data_sets_get_min_frame_duration ()

amide_time_t        amitk_data_sets_get_min_frame_duration
                                                        (GList *objects);


amitk_data_sets_get_min_voxel_size ()

amide_real_t        amitk_data_sets_get_min_voxel_size  (GList *objects);


amitk_data_sets_get_slices ()

GList *             amitk_data_sets_get_slices          (GList *objects,
                                                         GList **pslice_cache,
                                                         const gint max_slice_cache_size,
                                                         const amide_time_t start,
                                                         const amide_time_t duration,
                                                         const amide_intpoint_t gate,
                                                         const AmitkCanvasPoint pixel_size,
                                                         const AmitkVolume *view_volume);


amitk_data_sets_math_binary ()

AmitkDataSet *      amitk_data_sets_math_binary         (AmitkDataSet *ds1,
                                                         AmitkDataSet *ds2,
                                                         AmitkOperationBinary operation,
                                                         amide_data_t parameter0,
                                                         gboolean by_frame,
                                                         gboolean maintain_ds1_dim,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);


amitk_data_sets_math_unary ()

AmitkDataSet *      amitk_data_sets_math_unary          (AmitkDataSet *ds1,
                                                         AmitkOperationUnary operation,
                                                         amide_data_t parameter0,
                                                         amide_data_t parameter1,
                                                         AmitkUpdateFunc update_func,
                                                         gpointer update_data);


amitk_data_sets_remove_with_slice_parent ()

GList *             amitk_data_sets_remove_with_slice_parent
                                                        (GList *slices,
                                                         const AmitkDataSet *slice_parent);


amitk_dose_unit_convert_from ()

amide_data_t        amitk_dose_unit_convert_from        (const amide_data_t dose,
                                                         const AmitkDoseUnit dose_unit);


amitk_dose_unit_convert_to ()

amide_data_t        amitk_dose_unit_convert_to          (const amide_data_t MBq,
                                                         const AmitkDoseUnit dose_unit);


amitk_dose_unit_get_name ()

const gchar *       amitk_dose_unit_get_name            (const AmitkDoseUnit dose_unit);


amitk_interpolation_get_name ()

const gchar *       amitk_interpolation_get_name        (const AmitkInterpolation interpolation);


amitk_operation_binary_get_name ()

const gchar *       amitk_operation_binary_get_name     (const AmitkOperationBinary operation);


amitk_operation_unary_get_name ()

const gchar *       amitk_operation_unary_get_name      (const AmitkOperationUnary operation);


amitk_rendering_explanation

extern const gchar * amitk_rendering_explanation;


amitk_rendering_get_name ()

const gchar *       amitk_rendering_get_name            (const AmitkRendering rendering);


amitk_scaling_type_get_name ()

const gchar *       amitk_scaling_type_get_name         (const AmitkScalingType scaling_type);


amitk_subject_orientation_get_name ()

const gchar *       amitk_subject_orientation_get_name  (const AmitkSubjectOrientation subject_orientation);


amitk_subject_sex_get_name ()

const gchar *       amitk_subject_sex_get_name          (const AmitkSubjectSex subject_sex);


amitk_threshold_style_get_name ()

const gchar *       amitk_threshold_style_get_name      (const AmitkThresholdStyle threshold_style);


amitk_thresholding_get_name ()

const gchar *       amitk_thresholding_get_name         (const AmitkThresholding thresholding);


amitk_weight_unit_convert_from ()

amide_data_t        amitk_weight_unit_convert_from      (const amide_data_t weight,
                                                         const AmitkWeightUnit weight_unit);


amitk_weight_unit_convert_to ()

amide_data_t        amitk_weight_unit_convert_to        (const amide_data_t kg,
                                                         const AmitkWeightUnit weight_unit);


amitk_weight_unit_get_name ()

const gchar *       amitk_weight_unit_get_name          (const AmitkWeightUnit weight_unit);

Signal Details

The "color-table-changed" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        AmitkViewMode arg1,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.

The "color-table-independent-changed" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        AmitkViewMode arg1,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.

The "conversion-changed" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.

The "data-set-changed" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.

The "interpolation-changed" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.

The "invalidate-slice-cache" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.

The "modality-changed" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.

The "rendering-changed" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.

The "scale-factor-changed" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.

The "subject-orientation-changed" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.

The "subject-sex-changed" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.

The "threshold-style-changed" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.

The "thresholding-changed" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.

The "thresholds-changed" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.

The "time-changed" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.

The "view-gates-changed" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.

The "voxel-size-changed" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.

The "windows-changed" signal

void                user_function                      (AmitkDataSet *amitkdataset,
                                                        gpointer      user_data)         : Run Last

amitkdataset :

the object which received the signal.

user_data :

user data set when the signal handler was connected.