Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members  

NEWIMAGE Namespace Reference

Compounds

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

typedef AVW NEWIMAGE::volumeinfo
 

Enumeration Type Documentation

enum NEWIMAGE::costfns
 

Enumeration values:
Woods 
CorrRatio 
MutualInfo 
NormCorr 
NormMI 
LeastSq 
NormCorrSinc 

enum NEWIMAGE::extrapolation
 

Enumeration values:
zeropad 
constpad 
extraslice 
mirror 
periodic 
boundsassert 
boundsexception 
userextrapolation 

enum NEWIMAGE::interpolation
 

Enumeration values:
nearestneighbour 
trilinear 
sinc 
userkernel 
userinterpolation 

Function Documentation

template<class T>
volume4D< T > NEWIMAGE::abs (  const volume4D< T > &    vol ) 
 

template<class T>
volume< T > NEWIMAGE::abs (  const volume< T > &    vol ) 
 

volume< float > NEWIMAGE::abs (  const volume< float > &    realvol,
const volume< float > &    imagvol
) 
 

void NEWIMAGE::addpair2set (  int    x,
int    y,
std::vector< int > &    sx,
std::vector< int > &    sy
) 
 

template<class T>
void NEWIMAGE::affine_transform (  const volume< T > &    vin,
volume< T > &    vout,
const Matrix &    aff,
interpolation    interptype,
float    paddingsize = 0.0
) 
 

template<class T>
void NEWIMAGE::affine_transform (  const volume< T > &    vin,
volume< T > &    vout,
const Matrix &    aff,
float    paddingsize = 0.0
) 
 

template<class T>
void affine_transform_mask (  const volume< T > &    vin,
volume< T > &    vout,
const Matrix &    aff,
float    padding,
const T    padval
) 
 

template<class T>
volume< T > NEWIMAGE::affine_transform_mask (  const volume< T > &    vin,
const volume< T > &    vout,
const Matrix &    aff,
float    padding = 0.0
) 
 

template<class T>
void AvwReadBuffer (  AVW *    IP,
T *    tbuffer
) 
 

void AvwReadComplexBuffer (  AVW *    IP,
float *    realbuffer,
float *    imagbuffer
) 
 

void AvwWriteComplexVolume (  AVW *    OP,
const float *    realbuffer,
const float *    imagbuffer
) 
 

template<class T>
volume4D< T > NEWIMAGE::binarise (  const volume4D< T > &    vol,
T    thresh
) 
 

template<class T>
volume4D< T > NEWIMAGE::binarise (  const volume4D< T > &    vol,
T    lowerth,
T    upperth
) 
 

template<class T>
volume< T > NEWIMAGE::binarise (  const volume< T > &    vol,
T    thresh
) 
 

template<class T>
volume< T > NEWIMAGE::binarise (  const volume< T > &    vol,
T    lowerth,
T    upperth
) 
 

template<class T>
volume< T > NEWIMAGE::blur (  const volume< T > &    source,
float    iso_resel_size
) 
 

template<class T>
volume< T > NEWIMAGE::blur (  const volume< T > &    source,
const ColumnVector &    resel_size
) 
 

template<class T>
T NEWIMAGE::calc_backgroundval (  const volume< T > &    vol ) 
 

template<class T>
T calc_bval (  const volume< T > &    vol,
unsigned int    edgewidth
) 
 

template<class T>
ColumnVector NEWIMAGE::calc_cog (  const volume< T > &    vol ) 
 

void calc_entropy (  const volume< float > &    vref,
const volume< float > &    vtest,
int *    bindex,
const Matrix &    aff,
const float    mintest,
const float    maxtest,
const int    no_bins,
const ColumnVector &    plnp,
int *    jointhist,
int *    marghist1,
int *    marghist2,
float &    jointentropy,
float &    margentropy1,
float &    margentropy2
) 
 

void calc_fully_weighted_entropy (  const volume< float > &    vref,
const volume< float > &    vtest,
const volume< float > &    refweight,
const volume< float > &    testweight,
int *    bindex,
const Matrix &    aff,
const float    mintest,
const float    maxtest,
const int    no_bins,
float *    jointhist,
float *    marghist1,
float *    marghist2,
float &    jointentropy,
float &    margentropy1,
float &    margentropy2,
const float    smoothsize,
const float    fuzzyfrac
) 
 

template<class T>
int calc_histogram (  const volume< T > &    vol,
int    nbins,
double    minval,
double    maxval,
ColumnVector &    hist
) 
 

template<class T>
ColumnVector NEWIMAGE::calc_histogram (  const volume< T > &    vol ) 
 

template<class T>
std::vector< T > NEWIMAGE::calc_minmax (  const volume4D< T > &    source ) 
 

template<class T>
std::vector< T > NEWIMAGE::calc_minmax (  const volume< T > &    vol ) 
 

template<class T>
std::vector< T > NEWIMAGE::calc_percentiles (  const volume< T > &    vol ) 
 

template<class T>
Matrix NEWIMAGE::calc_principleaxes (  const volume< T > &    vol ) 
 

template<class T>
std::vector< T > NEWIMAGE::calc_robustlimits (  const volume< T > &    vol ) 
 

void calc_smoothed_entropy (  const volume< float > &    vref,
const volume< float > &    vtest,
int *    bindex,
const Matrix &    aff,
const float    mintest,
const float    maxtest,
const int    no_bins,
float *    jointhist,
float *    marghist1,
float *    marghist2,
float &    jointentropy,
float &    margentropy1,
float &    margentropy2,
const float    smoothsize,
const float    fuzzyfrac
) 
 

template<class T>
std::vector< float > NEWIMAGE::calc_sums (  const volume< T > &    vol ) 
 

void NEWIMAGE::check_filename (  const string &    basename ) 
 

template<class T>
void NEWIMAGE::clamp (  volume4D< T > &    vol,
T    minval,
T    maxval
) 
 

template<class T>
void NEWIMAGE::clamp (  volume< T > &    vol,
T    minval,
T    maxval
) 
 

template<class T>
volume< int > NEWIMAGE::connected_components (  const volume< T > &    vol,
const volume< T > &    mask,
bool(*    binaryrelation)(T, T)
) 
 

template<class T>
volume< int > NEWIMAGE::connected_components (  const volume< T > &    vol,
int    numconnected = 26
) 
 

template<class S, class D>
void NEWIMAGE::convertbuffer (  const S *    source,
D *    dest,
int    len
) 
 

template<class T, class S>
volume< T > NEWIMAGE::convolve (  const volume< T > &    source,
const volume< S > &    kernel
) 
 

template<class T, class S>
volume< T > NEWIMAGE::convolve_separable (  const volume< T > &    source,
const ColumnVector &    kernelx,
const ColumnVector &    kernely,
const ColumnVector &    kernelz
) 
 

template<class T>
int coordval (  const volume< T > &    vol,
int    x,
int    y,
int    z,
int    dim
)  [inline]
 

template<class S, class D>
void copybasicproperties (  const volume4D< S > &    source,
volume4D< D > &    dest
) 
 

template<class S, class D>
void copybasicproperties (  const volume< S > &    source,
volume< D > &    dest
) 
 

template<class S, class D>
void copyconvert (  const volume4D< S > &    source,
volume4D< D > &    dest
) 
 

template<class S, class D>
void copyconvert (  const volume< S > &    source,
volume< D > &    dest
) 
 

template<class T, class S>
volume4D< T > NEWIMAGE::divide (  const volume4D< T > &    numervol,
const volume< T > &    denomvol,
const volume< S > &    mask
) 
 

template<class T, class S>
volume4D< T > NEWIMAGE::divide (  const volume4D< T > &    numervol,
const volume4D< T > &    denomvol,
const volume< S > &    mask
) 
 

template<class T, class S>
volume< T > NEWIMAGE::divide (  const volume< T > &    numervol,
const volume< T > &    denomvol,
const volume< S > &    mask
) 
 

template<class T>
volume< float > NEWIMAGE::dotproductvol (  const volume4D< T > &    vol4,
const ColumnVector &    vec
) 
 

short NEWIMAGE::dtype (  const string &    filename ) 
 

short NEWIMAGE::dtype (  const volume4D< double > &    vol ) 
 

short NEWIMAGE::dtype (  const volume4D< float > &    vol ) 
 

short NEWIMAGE::dtype (  const volume4D< int > &    vol ) 
 

short NEWIMAGE::dtype (  const volume4D< short > &    vol ) 
 

short NEWIMAGE::dtype (  const volume4D< char > &    vol ) 
 

short NEWIMAGE::dtype (  const volume< double > &    vol ) 
 

short NEWIMAGE::dtype (  const volume< float > &    vol ) 
 

short NEWIMAGE::dtype (  const volume< int > &    vol ) 
 

short NEWIMAGE::dtype (  const volume< short > &    vol ) 
 

short NEWIMAGE::dtype (  const volume< char > &    vol ) 
 

short NEWIMAGE::dtype (  const double *    T ) 
 

short NEWIMAGE::dtype (  const float *    T ) 
 

short NEWIMAGE::dtype (  const int *    T ) 
 

short NEWIMAGE::dtype (  const short *    T ) 
 

short NEWIMAGE::dtype (  const char *    T ) 
 

int NEWIMAGE::find_first_nonzero (  const Matrix &    mat ) 
 

template<class T>
int find_histogram (  const volume< T > &    vol,
ColumnVector &    hist,
int    bins,
T &    min,
T &    max
) 
 

int NEWIMAGE::find_pathname (  string &    filename ) 
 

template<class T>
void find_thresholds (  const volume< T > &    vol,
int    bins,
ColumnVector &    hist,
T &    minval,
T &    maxval
) 
 

void findrangex (  unsigned int &    xmin1,
unsigned int &    xmax1,
float    o1,
float    o2,
float    o3,
float    a11,
float    a21,
float    a31,
unsigned int    xb1,
unsigned int    yb1,
unsigned int    zb1,
float    xb2,
float    yb2,
float    zb2
) 
 

template<class T>
volume< T > NEWIMAGE::fixed_edge_detect (  const volume< T > &    source,
float    threshold,
bool    twodimensional = false
) 
 

ColumnVector NEWIMAGE::gaussian_kernel1D (  float    sigma,
int    radius
) 
 

volume< float > NEWIMAGE::gaussian_kernel2D (  float    sigma,
int    radius
) 
 

volume< float > NEWIMAGE::gaussian_kernel3D (  float    sigma,
int    radius
) 
 

int* get_bindexptr (  unsigned int    x,
unsigned int    y,
unsigned int    z,
const volume< float > &    refvol,
int *    bindex
)  [inline]
 

int NEWIMAGE::get_medx_matrix (  Matrix &    target,
ifstream &    matfile
) 
 

int NEWIMAGE::get_medx_small_matrix (  Matrix &    target,
ifstream &    matfile
) 
 

int NEWIMAGE::get_minc_matrix (  Matrix &    target,
ifstream &    matfile
) 
 

int NEWIMAGE::get_outputusermat (  const string &    filename,
Matrix &    oumat
) 
 

void get_parent_label (  int &    idx,
const Matrix &    idxmap
)  [inline]
 

template<class T>
int get_pval_index (  const std::vector< T > &    pvals,
float    p
) 
 

template<class T>
volume< float > NEWIMAGE::gradient (  const volume< T > &    source ) 
 

volume< float > NEWIMAGE::imag (  const volume< float > &    absvol,
const volume< float > &    phasevol
) 
 

void NEWIMAGE::imthrow (  const string &    msg,
int    nierrnum
) 
 

bool in_interp_bounds (  const volume< float > &    v,
const float    x,
const float    y,
const float    z
)  [inline]
 

template<class T>
bool in_neigh_bounds (  const volume< T > &    vol,
int    x,
int    y,
int    z
) 
 

template<class T>
void NEWIMAGE::indexadd (  volume4D< T > &    vola,
const volume4D< T > &    volb,
const Matrix &    indices
) 
 

template<class T>
void NEWIMAGE::indexadd (  volume< T > &    vola,
const volume< T > &    volb,
const Matrix &    indices
) 
 

template<class T>
void NEWIMAGE::indexdivide (  volume4D< T > &    vola,
const volume4D< T > &    volb,
const Matrix &    indices
) 
 

template<class T>
void NEWIMAGE::indexdivide (  volume< T > &    vola,
const volume< T > &    volb,
const Matrix &    indices
) 
 

template<class T>
void NEWIMAGE::indexmultiply (  volume4D< T > &    vola,
const volume4D< T > &    volb,
const Matrix &    indices
) 
 

template<class T>
void NEWIMAGE::indexmultiply (  volume< T > &    vola,
const volume< T > &    volb,
const Matrix &    indices
) 
 

template<class T>
void NEWIMAGE::indexset (  volume4D< T > &    vola,
const Matrix &    indices,
const T    num
) 
 

template<class T>
void NEWIMAGE::indexset (  volume< T > &    vola,
const Matrix &    indices,
const T    num
) 
 

template<class T>
void NEWIMAGE::indexsubtract (  volume4D< T > &    vola,
const volume4D< T > &    volb,
const Matrix &    indices
) 
 

template<class T>
void NEWIMAGE::indexsubtract (  volume< T > &    vola,
const volume< T > &    volb,
const Matrix &    indices
) 
 

template<class T>
volume< T > NEWIMAGE::isotropic_resample (  const volume< T > &    aniso,
float    scale
) 
 

float length (  float    x,
float    y
) 
 

template<class T>
void load_avw_origin (  volume< T > &    vol,
AVW *    IP1
) 
 

template<class T>
volume< T > NEWIMAGE::log_edge_detect (  const volume< T > &    source,
float    sigma1,
float    sigma2,
float    zero_tolerance,
bool    twodimensional = false
) 
 

int NEWIMAGE::make_basename (  string &    filename ) 
 

void NEWIMAGE::make_blur_mask (  ColumnVector &    bmask,
const float    final_vox_dim,
const float    init_vox_dim
) 
 

template<class T>
void make_consistent_params (  const volume4D< T > &    vols,
int    t
) 
 

void NEWIMAGE::make_grad_masks (  volume< float > &    maskx,
volume< float > &    masky,
volume< float > &    maskz
) 
 

template<class T>
volume< float > NEWIMAGE::meanvol (  const volume4D< T > &    vol4 ) 
 

template<class T>
int medx2world (  Matrix &    target,
const Matrix &    medxmat,
const ColumnVector &    finalimsize,
const Matrix &    finalvoxsize,
const volume< T > &    initvol
) 
 

template<class T>
int minc2world (  Matrix &    target,
const Matrix &    mincmat,
const volume< T > &    initvol,
const volume< T > &    finalvol
) 
 

int mirrorclamp (  int    x,
int    x1,
int    x2
) 
 

AVW * NEWIMAGE::NewAvwOpen (  const string &    filename,
const string &    permissions
) 
 

AVW * NEWIMAGE::NewAvwOpen (  const string &    filename,
const string &    permissions,
const volumeinfo &    vinfo,
bool    use_vinfo
) 
 

template<class T>
long no_mask_voxels (  const volume< T > &    mask ) 
 

template<class T>
void nonunique_component_labels (  const volume< T > &    vol,
const volume< T > &    mask,
volume< int > &    labelvol,
std::vector< int > &    equivlista,
std::vector< int > &    equivlistb,
bool(*    binaryrelation)(T, T),
int    numconnected
) 
 

template<class T>
void nonunique_component_labels (  const volume< T > &    vol,
volume< int > &    labelvol,
std::vector< int > &    equivlista,
std::vector< int > &    equivlistb,
int    numconnected
) 
 

template<class S>
volume4D<S> operator * (  const volume< S > &    v1,
const volume4D< S > &    v2
) 
 

template<class S>
volume4D<S> operator * (  S    num,
const volume4D< S > &    vol
) 
 

template<class S>
volume<S> operator * (  S    num,
const volume< S > &    vol
) 
 

template<class S>
volume4D<S> operator+ (  const volume< S > &    v1,
const volume4D< S > &    v2
) 
 

template<class S>
volume4D<S> operator+ (  S    num,
const volume4D< S > &    vol
) 
 

template<class S>
volume<S> operator+ (  S    num,
const volume< S > &    vol
) 
 

template<class S>
volume4D<S> operator- (  const volume< S > &    v1,
const volume4D< S > &    v2
) 
 

template<class S>
volume4D<S> operator- (  S    num,
const volume4D< S > &    vol
) 
 

template<class S>
volume<S> operator- (  S    num,
const volume< S > &    vol
) 
 

template<class S>
volume4D<S> operator/ (  S    num,
const volume4D< S > &    vol
) 
 

template<class S>
volume<S> operator/ (  S    num,
const volume< S > &    vol
) 
 

float p_corr_ratio (  const volume< float > &    vref,
const volume< float > &    vtest,
int *    bindex,
const Matrix &    aff,
const int    no_bins
) 
 

float p_corr_ratio_fully_weighted (  const volume< float > &    vref,
const volume< float > &    vtest,
const volume< float > &    refweight,
const volume< float > &    testweight,
int *    bindex,
const Matrix &    aff,
const int    no_bins,
const float    smoothsize
) 
 

float p_corr_ratio_smoothed (  const volume< float > &    vref,
const volume< float > &    vtest,
int *    bindex,
const Matrix &    aff,
const int    no_bins,
const float    smoothsize
) 
 

float p_leastsquares (  const volume< float > &    vref,
const volume< float > &    vtest,
const Matrix &    aff
) 
 

float p_leastsquares_fully_weighted (  const volume< float > &    vref,
const volume< float > &    vtest,
const volume< float > &    refweight,
const volume< float > &    testweight,
const Matrix &    aff,
const float    smoothsize
) 
 

float p_leastsquares_smoothed (  const volume< float > &    vref,
const volume< float > &    vtest,
const Matrix &    aff,
const float    smoothsize
) 
 

float p_mutual_info (  const volume< float > &    vref,
const volume< float > &    vtest,
int *    bindex,
const Matrix &    aff,
const float    mintest,
const float    maxtest,
const int    no_bins,
const ColumnVector &    plnp,
int *    jointhist,
int *    marghist1,
int *    marghist2
) 
 

float p_mutual_info_fully_weighted (  const volume< float > &    vref,
const volume< float > &    vtest,
const volume< float > &    refweight,
const volume< float > &    testweight,
int *    bindex,
const Matrix &    aff,
const float    mintest,
const float    maxtest,
const int    no_bins,
float *    jointhist,
float *    marghist1,
float *    marghist2,
const float    smoothsize,
const float    fuzzyfrac
) 
 

float p_mutual_info_smoothed (  const volume< float > &    vref,
const volume< float > &    vtest,
int *    bindex,
const Matrix &    aff,
const float    mintest,
const float    maxtest,
const int    no_bins,
float *    jointhist,
float *    marghist1,
float *    marghist2,
const float    smoothsize,
const float    fuzzyfrac
) 
 

float p_normalised_mutual_info (  const volume< float > &    vref,
const volume< float > &    vtest,
int *    bindex,
const Matrix &    aff,
const float    mintest,
const float    maxtest,
const int    no_bins,
const ColumnVector &    plnp,
int *    jointhist,
int *    marghist1,
int *    marghist2
) 
 

float p_normalised_mutual_info_fully_weighted (  const volume< float > &    vref,
const volume< float > &    vtest,
const volume< float > &    refweight,
const volume< float > &    testweight,
int *    bindex,
const Matrix &    aff,
const float    mintest,
const float    maxtest,
const int    no_bins,
float *    jointhist,
float *    marghist1,
float *    marghist2,
const float    smoothsize,
const float    fuzzyfrac
) 
 

float p_normalised_mutual_info_smoothed (  const volume< float > &    vref,
const volume< float > &    vtest,
int *    bindex,
const Matrix &    aff,
const float    mintest,
const float    maxtest,
const int    no_bins,
float *    jointhist,
float *    marghist1,
float *    marghist2,
const float    smoothsize,
const float    fuzzyfrac
) 
 

float p_normcorr (  const volume< float > &    vref,
const volume< float > &    vtest,
const Matrix &    aff
) 
 

float p_normcorr_fully_weighted (  const volume< float > &    vref,
const volume< float > &    vtest,
const volume< float > &    refweight,
const volume< float > &    testweight,
const Matrix &    aff,
const float    smoothsize
) 
 

float p_normcorr_smoothed (  const volume< float > &    vref,
const volume< float > &    vtest,
const Matrix &    aff,
const float    smoothsize
) 
 

float p_normcorr_smoothed_sinc (  const volume< float > &    vref,
const volume< float > &    vtest,
const Matrix &    aff,
const float    smoothsize
) 
 

float p_woods_fn (  const volume< float > &    vref,
const volume< float > &    vtest,
int *    bindex,
const Matrix &    aff,
const int    no_bins
) 
 

float p_woods_fn_smoothed (  const volume< float > &    vref,
const volume< float > &    vtest,
int *    bindex,
const Matrix &    aff,
const int    no_bins,
const float    smoothsize
) 
 

template<class T>
void NEWIMAGE::pad (  const volume< T > &    vol,
volume< T > &    paddedvol,
int    offsetx,
int    offsety,
int    offsetz
) 
 

template<class T>
void NEWIMAGE::pad (  const volume< T > &    vol,
volume< T > &    paddedvol
) 
 

volume< float > NEWIMAGE::phase (  const volume< float > &    realvol,
const volume< float > &    imagvol
) 
 

template<class T>
void print_info (  const volume4D< T > &    source,
const string &    name
) 
 

template<class T>
void print_info (  const volume< T > &    source,
const string &    name
) 
 

template<class T>
void NEWIMAGE::print_size (  const volume< T > &    source ) 
 

template<class T>
void NEWIMAGE::print_volume_info (  const volume4D< T > &    source,
const string &    name = ""
) 
 

template<class T>
void NEWIMAGE::print_volume_info (  const volume< T > &    source,
const string &    name = ""
) 
 

int NEWIMAGE::put_medx_matrix (  ofstream &    matfile,
const string &    name,
const Matrix &    affmat
) 
 

int pval_index_end (    ) 
 

float q_hanning (  float    x,
int    w
) 
 

float q_kernelval (  float    x,
int    w
) 
 

void q_setupkernel (    ) 
 

float q_sinc (  float    x ) 
 

float q_sinc_interpolation (  const volume< float > &    v,
const float    x,
const float    y,
const float    z
) 
 

float q_tri_interpolation (  float    v000,
float    v001,
float    v010,
float    v011,
float    v100,
float    v101,
float    v110,
float    v111,
float    dx,
float    dy,
float    dz
)  [inline]
 

float q_tri_interpolation (  const volume< float > &    v,
const float    x,
const float    y,
const float    z
)  [inline]
 

template<class T>
void raw_affine_transform (  const volume< T > &    vin,
volume< T > &    vout,
const Matrix &    aff
) 
 

int NEWIMAGE::read_ascii_matrix (  Matrix &    target,
const string &    filename
) 
 

int NEWIMAGE::read_ascii_matrix (  Matrix &    target,
ifstream &    matfile
) 
 

int NEWIMAGE::read_complexvolume (  volume< float > &    realvol,
volume< float > &    imagvol,
const string &    filename
) 
 

int read_complexvolume (  volume< float > &    realvol,
volume< float > &    imagvol,
const string &    filename,
volumeinfo &    vinfo,
bool    read_img_data
) 
 

int NEWIMAGE::read_complexvolume4D (  volume4D< float > &    realvol,
volume4D< float > &    imagvol,
const string &    filename,
volumeinfo &    vinfo
) 
 

int NEWIMAGE::read_complexvolume4D (  volume4D< float > &    realvol,
volume4D< float > &    imagvol,
const string &    filename
) 
 

int read_complexvolume4D (  volume4D< float > &    realvols,
volume4D< float > &    imagvols,
const string &    filename,
volumeinfo &    vinfo,
bool    read_img_data
) 
 

template<class T>
int NEWIMAGE::read_matrix (  Matrix &    target,
const string &    filename,
const volume< T > &    invol,
const volume< T > &    finalvol
) 
 

template<class T>
int NEWIMAGE::read_matrix (  Matrix &    target,
const string &    filename,
const volume< T > &    invol
) 
 

template<class T>
int read_medx_matrix (  Matrix &    target,
ifstream &    matfile,
const volume< T > &    invol
) 
 

template<class T>
int read_minc_matrix (  Matrix &    target,
ifstream &    matfile,
const volume< T > &    invol,
const volume< T > &    finalvol
) 
 

template<class T>
int read_volume (  volume< T > &    target,
const string &    filename,
volumeinfo &    vinfo,
short &    dtype,
bool    read_img_data
) 
 

template<class T>
int NEWIMAGE::read_volume (  volume< T > &    target,
const string &    filename,
volumeinfo &    vinfo
) 
 

template<class T>
int NEWIMAGE::read_volume (  volume< T > &    target,
const string &    filename
) 
 

template<class T>
int read_volume4D (  volume4D< T > &    target,
const string &    filename,
volumeinfo &    vinfo,
short &    dtype,
bool    read_img_data
) 
 

template<class T>
int NEWIMAGE::read_volume4D (  volume4D< T > &    target,
const string &    filename,
volumeinfo &    vinfo
) 
 

template<class T>
int NEWIMAGE::read_volume4D (  volume4D< T > &    target,
const string &    filename
) 
 

template<class T>
int NEWIMAGE::read_volume4D_hdr_only (  volume4D< T > &    target,
const string &    filename,
volumeinfo &    vinfo
) 
 

template<class T>
int NEWIMAGE::read_volume4D_hdr_only (  volume4D< T > &    target,
const string &    filename
) 
 

template<class T>
int NEWIMAGE::read_volume_hdr_only (  volume< T > &    target,
const string &    filename,
volumeinfo &    vinfo
) 
 

template<class T>
int NEWIMAGE::read_volume_hdr_only (  volume< T > &    target,
const string &    filename
) 
 

volume< float > NEWIMAGE::real (  const volume< float > &    absvol,
const volume< float > &    phasevol
) 
 

void NEWIMAGE::relabel_components_uniquely (  volume< int > &    labelvol,
const std::vector< int > &    equivlista,
const std::vector< int > &    equivlistb
) 
 

template<class S1, class S2>
bool NEWIMAGE::sameabssize (  const volume4D< S1 > &    vol1,
const volume4D< S2 > &    vol2
) 
 

template<class S1, class S2>
bool NEWIMAGE::sameabssize (  const volume< S1 > &    vol1,
const volume< S2 > &    vol2
) 
 

template<class S1, class S2>
bool NEWIMAGE::samesize (  const volume4D< S1 > &    vol1,
const volume4D< S2 > &    vol2
) 
 

template<class S1, class S2>
bool NEWIMAGE::samesize (  const volume< S1 > &    vol1,
const volume< S2 > &    vol2
) 
 

template<class T>
void save_avw_origin (  const volume< T > &    vol,
AVW *    IP1
) 
 

int NEWIMAGE::save_complexvolume (  const volume< float > &    realvol,
const volume< float > &    imagvol,
const string &    filename,
const volumeinfo &    vinfo
) 
 

int NEWIMAGE::save_complexvolume (  const volume< float > &    realvol,
const volume< float > &    imagvol,
const string &    filename
) 
 

int save_complexvolume (  const volume< float > &    realvol,
const volume< float > &    imagvol,
const string &    filename,
const volumeinfo &    vinfo,
bool    use_vinfo
) 
 

int NEWIMAGE::save_complexvolume4D (  const volume4D< float > &    realvol,
const volume4D< float > &    imagvol,
const string &    filename,
const volumeinfo &    vinfo
) 
 

int NEWIMAGE::save_complexvolume4D (  const volume4D< float > &    realvol,
const volume4D< float > &    imagvol,
const string &    filename
) 
 

int save_complexvolume4D (  const volume4D< float > &    realvols,
const volume4D< float > &    imagvols,
const string &    filename,
const volumeinfo &    vinfo,
bool    use_vinfo
) 
 

template<class T>
int save_volume (  const volume< T > &    source,
const string &    filename,
const volumeinfo &    vinfo,
bool    use_vinfo
) 
 

template<class T>
int NEWIMAGE::save_volume (  const volume< T > &    source,
const string &    filename,
const volumeinfo &    vinfo
) 
 

template<class T>
int NEWIMAGE::save_volume (  const volume< T > &    source,
const string &    filename
) 
 

template<class T>
int save_volume4D (  const volume4D< T > &    source,
const string &    filename,
const volumeinfo &    vinfo,
bool    use_vinfo
) 
 

template<class T>
int NEWIMAGE::save_volume4D (  const volume4D< T > &    source,
const string &    filename,
const volumeinfo &    vinfo
) 
 

template<class T>
int NEWIMAGE::save_volume4D (  const volume4D< T > &    source,
const string &    filename
) 
 

template<class T>
int save_volume4D_dtype (  const volume4D< T > &    source,
const string &    filename,
short    datatype,
const volumeinfo &    vinfo,
bool    use_vinfo
) 
 

template<class T>
int NEWIMAGE::save_volume4D_dtype (  const volume4D< T > &    source,
const string &    filename,
short    datatype
) 
 

template<class T>
int NEWIMAGE::save_volume4D_dtype (  const volume4D< T > &    source,
const string &    filename,
short    datatype,
const volumeinfo &    vinfo
) 
 

template<class T>
int save_volume4D_hdr_only (  const volume4D< T > &    source,
const string &    filename,
const volumeinfo &    vinfo,
bool    use_vinfo
) 
 

template<class T>
int NEWIMAGE::save_volume4D_hdr_only (  const volume4D< T > &    source,
const string &    filename
) 
 

template<class T>
int NEWIMAGE::save_volume4D_hdr_only (  const volume4D< T > &    source,
const string &    filename,
const volumeinfo &    vinfo
) 
 

template<class T>
int save_volume_dtype (  const volume< T > &    source,
const string &    filename,
short    datatype,
const volumeinfo &    vinfo,
bool    use_vinfo
) 
 

template<class T>
int NEWIMAGE::save_volume_dtype (  const volume< T > &    source,
const string &    filename,
short    datatype
) 
 

template<class T>
int NEWIMAGE::save_volume_dtype (  const volume< T > &    source,
const string &    filename,
short    datatype,
const volumeinfo &    vinfo
) 
 

template<class T>
int save_volume_hdr_only (  const volume< T > &    source,
const string &    filename,
const volumeinfo &    vinfo,
bool    use_vinfo
) 
 

template<class T>
int save_volume_hdr_only (  const volume< T > &    source,
const string &    filename,
const volumeinfo &    vinfo,
bool    use_vinfo,
int    tsize,
float    tdim
) 
 

template<class T>
int NEWIMAGE::save_volume_hdr_only (  const volume< T > &    source,
const string &    filename
) 
 

template<class T>
int NEWIMAGE::save_volume_hdr_only (  const volume< T > &    source,
const string &    filename,
const volumeinfo &    vinfo
) 
 

template<class T>
int set_AVW_hdr (  const volume< T > &    source,
AVW *    OP,
int    tsize,
float    tdim
) 
 

template<class T>
volume< T > NEWIMAGE::smooth (  const volume< T > &    source,
float    sigma_mm
) 
 

template<class T>
volume< T > NEWIMAGE::smooth2D (  const volume< T > &    source,
float    sigma_mm,
int    nulldir = 3
) 
 

template<class T>
volume< float > NEWIMAGE::stddevvol (  const volume4D< T > &    vol4 ) 
 

template<class T>
volume< T > NEWIMAGE::subsample_by_2 (  const volume< T > &    refvol ) 
 

template<class T>
volume< float > NEWIMAGE::sumsquaresvol (  const volume4D< T > &    vol4 ) 
 

template<class T>
volume< float > NEWIMAGE::sumvol (  const volume4D< T > &    vol4 ) 
 

template<class S>
S swapval (  S    xval,
S    yval,
S    zval,
int    dim
)  [inline]
 

template<class T>
volume4D< T > NEWIMAGE::threshold (  const volume4D< T > &    vol,
T    thresh
) 
 

template<class T>
volume4D< T > NEWIMAGE::threshold (  const volume4D< T > &    vol,
T    lowerth,
T    upperth
) 
 

template<class T>
volume< T > NEWIMAGE::threshold (  const volume< T > &    vol,
T    thresh
) 
 

template<class T>
volume< T > NEWIMAGE::threshold (  const volume< T > &    vol,
T    lowerth,
T    upperth
) 
 

template<class T>
volume< float > NEWIMAGE::variancevol (  const volume4D< T > &    vol4 ) 
 

volumeinfo NEWIMAGE::volinfo (  const string &    filename ) 
 

template<class T>
int world2medx (  Matrix &    medxmat,
const Matrix &    worldmat,
const ColumnVector &    finalimsize,
const Matrix &    finalvoxsize,
const volume< T > &    initvol
) 
 

template<class T>
int NEWIMAGE::write_medx_matrix (  const Matrix &    worldmat,
const string &    filename,
const volume< T > &    initvol,
const volume< T > &    finalvol,
const string &    mtype,
const string &    reffname
) 
 

Variable Documentation

int NEWIMAGE::Globalkernelwidth [static]
 

float NEWIMAGE::Globalsinckernel[201] [static]
 

const bool NEWIMAGE::USEASSERT = false
 

template class NEWIMAGE::volume4D< char >
 

template class NEWIMAGE::volume4D< double >
 

template class NEWIMAGE::volume4D< float >
 

template class NEWIMAGE::volume4D< int >
 

template class NEWIMAGE::volume4D< short >
 

template class NEWIMAGE::volume< char >
 

template class NEWIMAGE::volume< double >
 

template class NEWIMAGE::volume< float >
 

template class NEWIMAGE::volume< int >
 

template class NEWIMAGE::volume< short >
 

Generated on Fri Mar 7 18:22:55 2003 for newimage by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002