amitk_point

amitk_point —

Synopsis




enum        AmitkView;
enum        AmitkAxis;
enum        AmitkDim;
enum        AmitkLengthUnit;
#define     AMITK_TYPE_POINT
#define     AMITK_TYPE_VOXEL
#define     AMITK_TYPE_PIXEL
#define     AMITK_TYPE_CANVAS_POINT
#define     AMITK_TYPE_AXES
struct      AmitkPoint;
struct      AmitkVoxel;
struct      AmitkPixel;
struct      AmitkCanvasPoint;
GType       amitk_point_get_type            (void);
AmitkPoint* amitk_point_copy                (const AmitkPoint *point);
void        amitk_point_free                (AmitkPoint *point);
AmitkPoint  amitk_point_read_xml            (xmlNodePtr nodes,
                                             gchar *descriptor,
                                             gchar **perror_buf);
void        amitk_point_write_xml           (xmlNodePtr node,
                                             gchar *descriptor,
                                             AmitkPoint point);
GType       amitk_voxel_get_type            (void);
AmitkVoxel* amitk_voxel_copy                (const AmitkVoxel *voxel);
void        amitk_voxel_free                (AmitkVoxel *voxel);
AmitkVoxel  amitk_voxel_read_xml            (xmlNodePtr nodes,
                                             gchar *descriptor,
                                             gchar **perror_buf);
void        amitk_voxel_write_xml           (xmlNodePtr node,
                                             gchar *descriptor,
                                             AmitkVoxel voxel);
GType       amitk_pixel_get_type            (void);
AmitkPixel* amitk_pixel_copy                (const AmitkPixel *pixel);
void        amitk_pixel_free                (AmitkPixel *pixel);
GType       amitk_canvas_point_get_type     (void);
AmitkCanvasPoint* amitk_canvas_point_copy   (const AmitkCanvasPoint *point);
void        amitk_canvas_point_free         (AmitkCanvasPoint *point);
typedef     AmitkAxes[AMITK_AXIS_NUM];
GType       amitk_axes_get_type             (void);
AmitkAxes*  amitk_axes_copy                 (const AmitkAxes *axes);
void        amitk_axes_free                 (AmitkAxes *axes);
void        amitk_axes_copy_in_place        (AmitkAxes dest_axes,
                                             const AmitkAxes src_axes);
void        amitk_axes_transpose            (AmitkAxes axes);
void        amitk_axes_mult                 (const AmitkAxes const_axes1,
                                             const AmitkAxes const_axes2,
                                             AmitkAxes dest_axes);
void        amitk_axes_make_orthonormal     (AmitkAxes axes);
void        amitk_axes_rotate_on_vector     (AmitkAxes axes,
                                             AmitkPoint vector,
                                             amide_real_t theta);
AmitkPoint  amitk_axes_get_orthogonal_axis  (const AmitkAxes axes,
                                             const AmitkView which_view,
                                             const AmitkLayout which_layout,
                                             const AmitkAxis which_axis);
AmitkPoint  amitk_axes_get_normal_axis      (const AmitkAxes axes,
                                             const AmitkView which_view);
typedef     AmitkCorners[2];
GType       amitk_corners_get_type          (void);
void        amitk_corners_free              (AmitkCorners *corners);
AmitkCorners* amitk_corners_copy            (const AmitkCorners *corners);
#define     EPSILON
#define     EMPTY
#define     SIGMA_TO_FWHM
#define     SIGMA_TO_FWTM
#define     REAL_EQUAL                      (x,y)
#define     EQUAL_ZERO                      (fp1)
#define     POINT_EQUAL                     (point1,point2)
#define     VOXEL_EQUAL                     (voxel1,voxel2)
#define     VOXEL_TO_POINT                  (vox, vox_size, real)
#define     POINT_TO_VOXEL                  (real, vox_size, frame, gate, vox)
#define     POINT_MAX                       (point1)
#define     POINT_DOT_PRODUCT               (point1,point2)
#define     POINT_MAGNITUDE                 (point)
#define     POINT_ABS                       (point1,point2)
#define     POINT_ADD                       (point1,point2,point3)
#define     POINT_SUB                       (point1,point2,point3)
#define     POINT_MULT                      (point1,point2,point3)
#define     POINT_DIV                       (point1,point2,point3)
#define     POINT_DIFF                      (point1,point2,point3)
#define     POINT_CMULT                     (cm,point1,point3)
#define     POINT_MADD                      (cm,point1,dm,point2,point3)
AmitkPoint  canvas_point_2_point            (AmitkPoint volume_corner,
                                             gint width,
                                             gint height,
                                             gdouble x_offset,
                                             gdouble y_offset,
                                             AmitkCanvasPoint canvas_cpoint);
AmitkCanvasPoint point_2_canvas_point       (AmitkPoint volume_corner,
                                             gint width,
                                             gint height,
                                             gdouble x_offset,
                                             gdouble y_offset,
                                             AmitkPoint canvas_point);
void        voxel_print                     (gchar *message,
                                             const AmitkVoxel voxel);
amide_intpoint_t voxel_get_dim              (const AmitkVoxel voxel,
                                             const AmitkDim which_dim);
void        voxel_set_dim                   (AmitkVoxel *voxel,
                                             const AmitkDim which_dim,
                                             amide_intpoint_t value);
void        point_print                     (gchar *message,
                                             const AmitkPoint point);
AmitkPoint  point_rotate_on_vector          (const AmitkPoint in,
                                             const AmitkPoint vector,
                                             const amide_real_t theta);
amide_real_t point_get_component            (const AmitkPoint point,
                                             const AmitkAxis which_axis);
void        point_set_component             (AmitkPoint *point,
                                             const AmitkAxis which_axis,
                                             const amide_real_t value);
extern      const AmitkPoint zero_point;
extern      const AmitkPoint one_point;
extern      const AmitkPoint ten_point;
extern      const AmitkVoxel zero_voxel;
extern      const AmitkVoxel one_voxel;
extern      const AmitkAxes base_axes;
const gchar* amitk_view_get_name            (const AmitkView view);
const gchar* amitk_dim_get_name             (const AmitkDim dim);
const gchar* amitk_axis_get_name            (const AmitkAxis axis);
const gchar* amitk_length_unit_get_name     (const AmitkLengthUnit length_unit);

Description

Details

enum AmitkView

typedef enum {
  AMITK_VIEW_TRANSVERSE, 
  AMITK_VIEW_CORONAL, 
  AMITK_VIEW_SAGITTAL, 
  AMITK_VIEW_NUM
} AmitkView;


enum AmitkAxis

typedef enum {
  AMITK_AXIS_X,
  AMITK_AXIS_Y,
  AMITK_AXIS_Z,
  AMITK_AXIS_NUM
} AmitkAxis;


enum AmitkDim

typedef enum {
  AMITK_DIM_X,
  AMITK_DIM_Y,
  AMITK_DIM_Z,
  AMITK_DIM_G,
  AMITK_DIM_T,
  AMITK_DIM_NUM
} AmitkDim;


enum AmitkLengthUnit

typedef enum {
  AMITK_LENGTH_UNIT_MM,
  AMITK_LENGTH_UNIT_CM,
  AMITK_LENGTH_UNIT_M,
  AMITK_LENGTH_UNIT_INCHES,
  AMITK_LENGTH_UNIT_FEET,
  AMITK_LENGTH_UNIT_NUM
} AmitkLengthUnit;


AMITK_TYPE_POINT

#define	AMITK_TYPE_POINT		(amitk_point_get_type ())


AMITK_TYPE_VOXEL

#define AMITK_TYPE_VOXEL                (amitk_voxel_get_type ())


AMITK_TYPE_PIXEL

#define AMITK_TYPE_PIXEL                (amitk_pixel_get_type ())


AMITK_TYPE_CANVAS_POINT

#define AMITK_TYPE_CANVAS_POINT         (amitk_canvas_point_get_type ())


AMITK_TYPE_AXES

#define AMITK_TYPE_AXES                 (amitk_axes_get_type ())


struct AmitkPoint

struct AmitkPoint {

  amide_real_t x;
  amide_real_t y;
  amide_real_t z;
};


struct AmitkVoxel

struct AmitkVoxel {

  amide_intpoint_t x;
  amide_intpoint_t y;
  amide_intpoint_t z;
  amide_intpoint_t g;
  amide_intpoint_t t;
};


struct AmitkPixel

struct AmitkPixel {

  amide_intpoint_t x;
  amide_intpoint_t y;
};


struct AmitkCanvasPoint

struct AmitkCanvasPoint {

  amide_real_t x;
  amide_real_t y;
};


amitk_point_get_type ()

GType       amitk_point_get_type            (void);

Returns :

amitk_point_copy ()

AmitkPoint* amitk_point_copy                (const AmitkPoint *point);

point :
Returns :

amitk_point_free ()

void        amitk_point_free                (AmitkPoint *point);

point :

amitk_point_read_xml ()

AmitkPoint  amitk_point_read_xml            (xmlNodePtr nodes,
                                             gchar *descriptor,
                                             gchar **perror_buf);

nodes :
descriptor :
perror_buf :
Returns :

amitk_point_write_xml ()

void        amitk_point_write_xml           (xmlNodePtr node,
                                             gchar *descriptor,
                                             AmitkPoint point);

node :
descriptor :
point :

amitk_voxel_get_type ()

GType       amitk_voxel_get_type            (void);

Returns :

amitk_voxel_copy ()

AmitkVoxel* amitk_voxel_copy                (const AmitkVoxel *voxel);

voxel :
Returns :

amitk_voxel_free ()

void        amitk_voxel_free                (AmitkVoxel *voxel);

voxel :

amitk_voxel_read_xml ()

AmitkVoxel  amitk_voxel_read_xml            (xmlNodePtr nodes,
                                             gchar *descriptor,
                                             gchar **perror_buf);

nodes :
descriptor :
perror_buf :
Returns :

amitk_voxel_write_xml ()

void        amitk_voxel_write_xml           (xmlNodePtr node,
                                             gchar *descriptor,
                                             AmitkVoxel voxel);

node :
descriptor :
voxel :

amitk_pixel_get_type ()

GType       amitk_pixel_get_type            (void);

Returns :

amitk_pixel_copy ()

AmitkPixel* amitk_pixel_copy                (const AmitkPixel *pixel);

pixel :
Returns :

amitk_pixel_free ()

void        amitk_pixel_free                (AmitkPixel *pixel);

pixel :

amitk_canvas_point_get_type ()

GType       amitk_canvas_point_get_type     (void);

Returns :

amitk_canvas_point_copy ()

AmitkCanvasPoint* amitk_canvas_point_copy   (const AmitkCanvasPoint *point);

point :
Returns :

amitk_canvas_point_free ()

void        amitk_canvas_point_free         (AmitkCanvasPoint *point);

point :

AmitkAxes[AMITK_AXIS_NUM]

typedef AmitkPoint AmitkAxes[AMITK_AXIS_NUM];


amitk_axes_get_type ()

GType       amitk_axes_get_type             (void);

Returns :

amitk_axes_copy ()

AmitkAxes*  amitk_axes_copy                 (const AmitkAxes *axes);

axes :
Returns :

amitk_axes_free ()

void        amitk_axes_free                 (AmitkAxes *axes);

axes :

amitk_axes_copy_in_place ()

void        amitk_axes_copy_in_place        (AmitkAxes dest_axes,
                                             const AmitkAxes src_axes);

dest_axes :
src_axes :

amitk_axes_transpose ()

void        amitk_axes_transpose            (AmitkAxes axes);

axes :

amitk_axes_mult ()

void        amitk_axes_mult                 (const AmitkAxes const_axes1,
                                             const AmitkAxes const_axes2,
                                             AmitkAxes dest_axes);

const_axes1 :
const_axes2 :
dest_axes :

amitk_axes_make_orthonormal ()

void        amitk_axes_make_orthonormal     (AmitkAxes axes);

axes :

amitk_axes_rotate_on_vector ()

void        amitk_axes_rotate_on_vector     (AmitkAxes axes,
                                             AmitkPoint vector,
                                             amide_real_t theta);

axes :
vector :
theta :

amitk_axes_get_orthogonal_axis ()

AmitkPoint  amitk_axes_get_orthogonal_axis  (const AmitkAxes axes,
                                             const AmitkView which_view,
                                             const AmitkLayout which_layout,
                                             const AmitkAxis which_axis);

axes :
which_view :
which_layout :
which_axis :
Returns :

amitk_axes_get_normal_axis ()

AmitkPoint  amitk_axes_get_normal_axis      (const AmitkAxes axes,
                                             const AmitkView which_view);

axes :
which_view :
Returns :

AmitkCorners[2]

typedef AmitkPoint AmitkCorners[2];


amitk_corners_get_type ()

GType       amitk_corners_get_type          (void);

Returns :

amitk_corners_free ()

void        amitk_corners_free              (AmitkCorners *corners);

corners :

amitk_corners_copy ()

AmitkCorners* amitk_corners_copy            (const AmitkCorners *corners);

corners :
Returns :

EPSILON

#define EPSILON 1.4901161193847656e-08 /* what's close enough to be equal.... */


EMPTY

#define EMPTY 0.0


SIGMA_TO_FWHM

#define SIGMA_TO_FWHM 2.354820045 


SIGMA_TO_FWTM

#define SIGMA_TO_FWTM 4.291932053


REAL_EQUAL()

#define REAL_EQUAL(x,y) (fabs(x-y)/MAX(MAX(fabs(x),fabs(y)),DBL_MIN) < EPSILON)

x :
y :

EQUAL_ZERO()

#define EQUAL_ZERO(fp1) (REAL_EQUAL((fp1), 0.0))

fp1 :

POINT_EQUAL()

#define     POINT_EQUAL(point1,point2)

point1 :
point2 :

VOXEL_EQUAL()

#define     VOXEL_EQUAL(voxel1,voxel2)

voxel1 :
voxel2 :

VOXEL_TO_POINT()

#define     VOXEL_TO_POINT(vox, vox_size, real)

vox :
vox_size :
real :

POINT_TO_VOXEL()

#define     POINT_TO_VOXEL(real, vox_size, frame, gate, vox)

real :
vox_size :
frame :
gate :
vox :

POINT_MAX()

#define POINT_MAX(point1) (MAX( MAX((point1).x, (point1).y), (point1).z))

point1 :

POINT_DOT_PRODUCT()

#define POINT_DOT_PRODUCT(point1,point2) ((point1).x*(point2).x+(point1).y*(point2).y+(point1).z*(point2).z)

point1 :
point2 :

POINT_MAGNITUDE()

#define POINT_MAGNITUDE(point) (sqrt(POINT_DOT_PRODUCT((point), (point))))

point :

POINT_ABS()

#define     POINT_ABS(point1,point2)

point1 :
point2 :

POINT_ADD()

#define     POINT_ADD(point1,point2,point3)

point1 :
point2 :
point3 :

POINT_SUB()

#define     POINT_SUB(point1,point2,point3)

point1 :
point2 :
point3 :

POINT_MULT()

#define     POINT_MULT(point1,point2,point3)

point1 :
point2 :
point3 :

POINT_DIV()

#define     POINT_DIV(point1,point2,point3)

point1 :
point2 :
point3 :

POINT_DIFF()

#define     POINT_DIFF(point1,point2,point3)

point1 :
point2 :
point3 :

POINT_CMULT()

#define     POINT_CMULT(cm,point1,point3)

cm :
point1 :
point3 :

POINT_MADD()

#define     POINT_MADD(cm,point1,dm,point2,point3)

cm :
point1 :
dm :
point2 :
point3 :

canvas_point_2_point ()

AmitkPoint  canvas_point_2_point            (AmitkPoint volume_corner,
                                             gint width,
                                             gint height,
                                             gdouble x_offset,
                                             gdouble y_offset,
                                             AmitkCanvasPoint canvas_cpoint);

volume_corner :
width :
height :
x_offset :
y_offset :
canvas_cpoint :
Returns :

point_2_canvas_point ()

AmitkCanvasPoint point_2_canvas_point       (AmitkPoint volume_corner,
                                             gint width,
                                             gint height,
                                             gdouble x_offset,
                                             gdouble y_offset,
                                             AmitkPoint canvas_point);

volume_corner :
width :
height :
x_offset :
y_offset :
canvas_point :
Returns :

voxel_print ()

void        voxel_print                     (gchar *message,
                                             const AmitkVoxel voxel);

message :
voxel :

voxel_get_dim ()

amide_intpoint_t voxel_get_dim              (const AmitkVoxel voxel,
                                             const AmitkDim which_dim);

voxel :
which_dim :
Returns :

voxel_set_dim ()

void        voxel_set_dim                   (AmitkVoxel *voxel,
                                             const AmitkDim which_dim,
                                             amide_intpoint_t value);

voxel :
which_dim :
value :

point_print ()

void        point_print                     (gchar *message,
                                             const AmitkPoint point);

message :
point :

point_rotate_on_vector ()

AmitkPoint  point_rotate_on_vector          (const AmitkPoint in,
                                             const AmitkPoint vector,
                                             const amide_real_t theta);

in :
vector :
theta :
Returns :

point_get_component ()

amide_real_t point_get_component            (const AmitkPoint point,
                                             const AmitkAxis which_axis);

point :
which_axis :
Returns :

point_set_component ()

void        point_set_component             (AmitkPoint *point,
                                             const AmitkAxis which_axis,
                                             const amide_real_t value);

point :
which_axis :
value :

zero_point

extern const AmitkPoint zero_point;


one_point

extern const AmitkPoint one_point;


ten_point

extern const AmitkPoint ten_point;


zero_voxel

extern const AmitkVoxel zero_voxel;


one_voxel

extern const AmitkVoxel one_voxel;


base_axes

extern const AmitkAxes base_axes;


amitk_view_get_name ()

const gchar* amitk_view_get_name            (const AmitkView view);

view :
Returns :

amitk_dim_get_name ()

const gchar* amitk_dim_get_name             (const AmitkDim dim);

dim :
Returns :

amitk_axis_get_name ()

const gchar* amitk_axis_get_name            (const AmitkAxis axis);

axis :
Returns :

amitk_length_unit_get_name ()

const gchar* amitk_length_unit_get_name     (const AmitkLengthUnit length_unit);

length_unit :
Returns :