src/nrrd/enumsNrrd.c File Reference

#include "nrrd.h"

Include dependency graph for enumsNrrd.c:


Defines

#define ntCH   nrrdTypeChar
#define ntUC   nrrdTypeUChar
#define ntSH   nrrdTypeShort
#define ntUS   nrrdTypeUShort
#define ntIN   nrrdTypeInt
#define ntUI   nrrdTypeUInt
#define ntLL   nrrdTypeLLong
#define ntUL   nrrdTypeULLong
#define ntFL   nrrdTypeFloat
#define ntDB   nrrdTypeDouble
#define ntBL   nrrdTypeBlock
#define nuNeg   nrrdUnaryOpNegative
#define nuRcp   nrrdUnaryOpReciprocal
#define nuSin   nrrdUnaryOpSin
#define nuCos   nrrdUnaryOpCos
#define nuTan   nrrdUnaryOpTan
#define nuAsn   nrrdUnaryOpAsin
#define nuAcs   nrrdUnaryOpAcos
#define nuAtn   nrrdUnaryOpAtan
#define nuExp   nrrdUnaryOpExp
#define nuLge   nrrdUnaryOpLog
#define nuLg2   nrrdUnaryOpLog2
#define nuLgt   nrrdUnaryOpLog10
#define nuL1p   nrrdUnaryOpLog1p
#define nuSqt   nrrdUnaryOpSqrt
#define nuCbt   nrrdUnaryOpCbrt
#define nuErf   nrrdUnaryOpErf
#define nuCil   nrrdUnaryOpCeil
#define nuFlr   nrrdUnaryOpFloor
#define nuRup   nrrdUnaryOpRoundUp
#define nuRdn   nrrdUnaryOpRoundDown
#define nuAbs   nrrdUnaryOpAbs
#define nuSgn   nrrdUnaryOpSgn
#define nuExs   nrrdUnaryOpExists
#define nuRnd   nrrdUnaryOpRand
#define nuNrn   nrrdUnaryOpNormalRand
#define nuoIf   nrrdUnaryOpIf
#define nuZer   nrrdUnaryOpZero
#define nuOne   nrrdUnaryOpOne
#define nbAdd   nrrdBinaryOpAdd
#define nbSub   nrrdBinaryOpSubtract
#define nbMul   nrrdBinaryOpMultiply
#define nbDiv   nrrdBinaryOpDivide
#define nbPow   nrrdBinaryOpPow
#define nbSpw   nrrdBinaryOpSgnPow
#define nbMod   nrrdBinaryOpMod
#define nbFmd   nrrdBinaryOpFmod
#define nbAtn   nrrdBinaryOpAtan2
#define nbMin   nrrdBinaryOpMin
#define nbMax   nrrdBinaryOpMax
#define nbLt   nrrdBinaryOpLT
#define nbLte   nrrdBinaryOpLTE
#define nbGt   nrrdBinaryOpGT
#define nbGte   nrrdBinaryOpGTE
#define nbCmp   nrrdBinaryOpCompare
#define nbEq   nrrdBinaryOpEqual
#define nbNeq   nrrdBinaryOpNotEqual
#define nbExt   nrrdBinaryOpExists
#define nbIf   nrrdBinaryOpIf
#define ntAdd   nrrdTernaryOpAdd
#define ntMul   nrrdTernaryOpMultiply

Variables

char _nrrdFormatTypeStr [NRRD_FORMAT_TYPE_MAX+1][AIR_STRLEN_SMALL]
char _nrrdFormatTypeDesc [NRRD_FORMAT_TYPE_MAX+1][AIR_STRLEN_MED]
char _nrrdFormatTypeStrEqv [][AIR_STRLEN_SMALL]
int _nrrdFormatTypeValEqv []
airEnum _nrrdFormatType
airEnumnrrdFormatType = &_nrrdFormatType
char _nrrdTypeStr [NRRD_TYPE_MAX+1][AIR_STRLEN_SMALL]
char _nrrdTypeDesc [NRRD_TYPE_MAX+1][AIR_STRLEN_MED]
char _nrrdTypeStrEqv [][AIR_STRLEN_SMALL]
int _nrrdTypeValEqv []
airEnum _nrrdType
airEnumnrrdType = &_nrrdType
char _nrrdEncodingTypeStr [NRRD_ENCODING_TYPE_MAX+1][AIR_STRLEN_SMALL]
char _nrrdEncodingTypeDesc [NRRD_ENCODING_TYPE_MAX+1][AIR_STRLEN_MED]
char _nrrdEncodingTypeStrEqv [][AIR_STRLEN_SMALL]
int _nrrdEncodingTypeValEqv []
airEnum _nrrdEncodingType
airEnumnrrdEncodingType = &_nrrdEncodingType
char _nrrdCenterStr [NRRD_CENTER_MAX+1][AIR_STRLEN_SMALL]
char _nrrdCenterDesc [NRRD_CENTER_MAX+1][AIR_STRLEN_MED]
airEnum _nrrdCenter_enum
airEnumnrrdCenter = &_nrrdCenter_enum
char _nrrdKindStr [NRRD_KIND_MAX+1][AIR_STRLEN_SMALL]
char _nrrdKindDesc [NRRD_KIND_MAX+1][AIR_STRLEN_MED]
char _nrrdKindStr_Eqv [][AIR_STRLEN_SMALL]
int _nrrdKindVal_Eqv []
airEnum _nrrdKind_enum
airEnumnrrdKind = &_nrrdKind_enum
char _nrrdFieldStr [NRRD_FIELD_MAX+1][AIR_STRLEN_SMALL]
char _nrrdFieldDesc [NRRD_FIELD_MAX+1][AIR_STRLEN_MED]
char _nrrdFieldStrEqv [][AIR_STRLEN_SMALL]
int _nrrdFieldValEqv []
airEnum _nrrdField
airEnumnrrdField = &_nrrdField
char _nrrdSpaceStr [NRRD_SPACE_MAX+1][AIR_STRLEN_SMALL]
char _nrrdSpaceDesc [NRRD_SPACE_MAX+1][AIR_STRLEN_MED]
char _nrrdSpaceStrEqv [][AIR_STRLEN_SMALL]
int _nrrdSpaceValEqv []
airEnum _nrrdSpace
airEnumnrrdSpace = &_nrrdSpace
char _nrrdBoundaryStr [NRRD_BOUNDARY_MAX+1][AIR_STRLEN_SMALL]
char _nrrdBoundaryDesc [NRRD_BOUNDARY_MAX+1][AIR_STRLEN_MED]
airEnum _nrrdBoundary
airEnumnrrdBoundary = &_nrrdBoundary
char _nrrdMeasureStr [NRRD_MEASURE_MAX+1][AIR_STRLEN_SMALL]
char _nrrdMeasureDesc [NRRD_MEASURE_MAX+1][AIR_STRLEN_MED]
char _nrrdMeasureStrEqv [][AIR_STRLEN_SMALL]
int _nrrdMeasureValEqv []
airEnum _nrrdMeasure
airEnumnrrdMeasure = &_nrrdMeasure
char _nrrdUnaryOpStr [NRRD_UNARY_OP_MAX+1][AIR_STRLEN_SMALL]
char _nrrdUnaryOpDesc [NRRD_UNARY_OP_MAX+1][AIR_STRLEN_MED]
char _nrrdUnaryOpStrEqv [][AIR_STRLEN_SMALL]
int _nrrdUnaryOpValEqv []
airEnum _nrrdUnaryOp_enum
airEnumnrrdUnaryOp = &_nrrdUnaryOp_enum
char _nrrdBinaryOpStr [NRRD_BINARY_OP_MAX+1][AIR_STRLEN_SMALL]
char _nrrdBinaryOpDesc [NRRD_BINARY_OP_MAX+1][AIR_STRLEN_MED]
char _nrrdBinaryOpStrEqv [][AIR_STRLEN_SMALL]
int _nrrdBinaryOpValEqv []
airEnum _nrrdBinaryOp_enum
airEnumnrrdBinaryOp = &_nrrdBinaryOp_enum
char _nrrdTernaryOpStr [NRRD_TERNARY_OP_MAX+1][AIR_STRLEN_SMALL]
char _nrrdTernaryOpDesc [NRRD_TERNARY_OP_MAX+1][AIR_STRLEN_MED]
char _nrrdTernaryOpStrEqv [][AIR_STRLEN_SMALL]
int _nrrdTernaryOpValEqv []
airEnum _nrrdTernaryOp_enum
airEnumnrrdTernaryOp = &_nrrdTernaryOp_enum

Define Documentation

#define nbAdd   nrrdBinaryOpAdd

#define nbAtn   nrrdBinaryOpAtan2

#define nbCmp   nrrdBinaryOpCompare

#define nbDiv   nrrdBinaryOpDivide

#define nbEq   nrrdBinaryOpEqual

#define nbExt   nrrdBinaryOpExists

#define nbFmd   nrrdBinaryOpFmod

#define nbGt   nrrdBinaryOpGT

#define nbGte   nrrdBinaryOpGTE

#define nbIf   nrrdBinaryOpIf

#define nbLt   nrrdBinaryOpLT

#define nbLte   nrrdBinaryOpLTE

#define nbMax   nrrdBinaryOpMax

#define nbMin   nrrdBinaryOpMin

#define nbMod   nrrdBinaryOpMod

#define nbMul   nrrdBinaryOpMultiply

#define nbNeq   nrrdBinaryOpNotEqual

#define nbPow   nrrdBinaryOpPow

#define nbSpw   nrrdBinaryOpSgnPow

#define nbSub   nrrdBinaryOpSubtract

#define ntAdd   nrrdTernaryOpAdd

#define ntBL   nrrdTypeBlock

#define ntCH   nrrdTypeChar

#define ntDB   nrrdTypeDouble

#define ntFL   nrrdTypeFloat

#define ntIN   nrrdTypeInt

#define ntLL   nrrdTypeLLong

#define ntMul   nrrdTernaryOpMultiply

#define ntSH   nrrdTypeShort

#define ntUC   nrrdTypeUChar

#define ntUI   nrrdTypeUInt

#define ntUL   nrrdTypeULLong

#define ntUS   nrrdTypeUShort

#define nuAbs   nrrdUnaryOpAbs

#define nuAcs   nrrdUnaryOpAcos

#define nuAsn   nrrdUnaryOpAsin

#define nuAtn   nrrdUnaryOpAtan

#define nuCbt   nrrdUnaryOpCbrt

#define nuCil   nrrdUnaryOpCeil

#define nuCos   nrrdUnaryOpCos

#define nuErf   nrrdUnaryOpErf

#define nuExp   nrrdUnaryOpExp

#define nuExs   nrrdUnaryOpExists

#define nuFlr   nrrdUnaryOpFloor

#define nuL1p   nrrdUnaryOpLog1p

#define nuLg2   nrrdUnaryOpLog2

#define nuLge   nrrdUnaryOpLog

#define nuLgt   nrrdUnaryOpLog10

#define nuNeg   nrrdUnaryOpNegative

#define nuNrn   nrrdUnaryOpNormalRand

#define nuoIf   nrrdUnaryOpIf

#define nuOne   nrrdUnaryOpOne

#define nuRcp   nrrdUnaryOpReciprocal

#define nuRdn   nrrdUnaryOpRoundDown

#define nuRnd   nrrdUnaryOpRand

#define nuRup   nrrdUnaryOpRoundUp

#define nuSgn   nrrdUnaryOpSgn

#define nuSin   nrrdUnaryOpSin

#define nuSqt   nrrdUnaryOpSqrt

#define nuTan   nrrdUnaryOpTan

#define nuZer   nrrdUnaryOpZero


Variable Documentation

char _nrrdBinaryOpDesc[NRRD_BINARY_OP_MAX+1][AIR_STRLEN_MED]

Initial value:

 {
  "unknown binary op",
  "add",
  "subtract",
  "multiply",
  "divide",
  "power",
  "signed power",
  "integer modulo",
  "fractional modulo",
  "two-argment arctangent based on atan2()",
  "miniumum",
  "maximum",
  "less then",
  "less then or equal",
  "greater than",
  "greater than or equal",
  "compare (resulting in -1, 0, or 1)",
  "equal",
  "not equal",
  "if exists(a), then a, else b",
  "if a, then a, else b",
  "a + b*gaussianNoise",
}

char _nrrdBinaryOpStr[NRRD_BINARY_OP_MAX+1][AIR_STRLEN_SMALL]

Initial value:

 {
  "(unknown_binary_op)",
  "+",
  "-",
  "x",
  "/",
  "^",
  "spow",
  "%",
  "fmod",
  "atan2",
  "min",
  "max",
  "lt",
  "lte",
  "gt",
  "gte",
  "comp",
  "eq",
  "neq",
  "exists",
  "if",
  "nrand"
}

char _nrrdBinaryOpStrEqv[][AIR_STRLEN_SMALL]

Initial value:

 {
  "+", "plus", "add",
  "-", "minus", "subtract", "sub", 
  "x", "*", "times", "multiply", "product",
  "/", "divide", "quotient",
  "^", "pow", "power",
  "spow", "sgnpow", "sgnpower",
  "%", "mod", "modulo",
  "fmod",
  "atan2", 
  "min", "minimum",
  "max", "maximum",
  "lt", "<", "less", "lessthan",
  "lte", "<=", "lessthanorequal",
  "gt", ">", "greater", "greaterthan",
  "gte", ">=", "greaterthanorequal",
  "comp", "compare",
  "eq", "=", "==", "equal",
  "neq", "ne", "!=", "notequal",
  "exists",
  "if",
  "nrand",
  ""
}

Initial value:

 {
  nbAdd, nbAdd, nbAdd,
  nbSub, nbSub, nbSub, nbSub, 
  nbMul, nbMul, nbMul, nbMul, nbMul, 
  nbDiv, nbDiv, nbDiv, 
  nbPow, nbPow, nbPow,
  nbSpw, nbSpw, nbSpw,
  nbMod, nbMod, nbMod, 
  nbFmd,
  nbAtn,
  nbMin, nbMin,
  nbMax, nbMax,
  nbLt, nbLt, nbLt, nbLt,
  nbLte, nbLte, nbLte,
  nbGt, nbGt, nbGt, nbGt,
  nbGte, nbGte, nbGte,
  nbCmp, nbCmp,
  nbEq, nbEq, nbEq, nbEq,
  nbNeq, nbNeq, nbNeq, nbNeq,
  nbExt,
  nbIf,
  nrrdBinaryOpNormalRandScaleAdd
}

Initial value:

 {
  "boundary behavior",
  NRRD_BOUNDARY_MAX,
  _nrrdBoundaryStr, NULL,
  _nrrdBoundaryDesc,
  NULL, NULL,
  AIR_FALSE
}

char _nrrdBoundaryDesc[NRRD_BOUNDARY_MAX+1][AIR_STRLEN_MED]

Initial value:

 {
  "unknown boundary behavior",
  "pad with some specified value",
  "copy values from edge outward as needed",
  "wrap around to other end of axis",
  "re-weight (by normalization) samples within axis range",
}

char _nrrdBoundaryStr[NRRD_BOUNDARY_MAX+1][AIR_STRLEN_SMALL]

Initial value:

 {
  "(unknown_boundary)",
  "pad",
  "bleed",
  "wrap",
  "weight",
}

Initial value:

 {
  "centering",
  NRRD_CENTER_MAX,
  _nrrdCenterStr, NULL,
  _nrrdCenterDesc,
  NULL, NULL,
  AIR_FALSE
}

char _nrrdCenterDesc[NRRD_CENTER_MAX+1][AIR_STRLEN_MED]

Initial value:

 {
  "unknown centering",
  "samples are at boundaries between elements along axis",
  "samples are at centers of elements along axis",
}

char _nrrdCenterStr[NRRD_CENTER_MAX+1][AIR_STRLEN_SMALL]

Initial value:

 {
  "(unknown_center)",
  "node",
  "cell",
}

char _nrrdEncodingTypeDesc[NRRD_ENCODING_TYPE_MAX+1][AIR_STRLEN_MED]

Initial value:

 {
  "unknown encoding",
  "file is byte-for-byte same as memory representation",
  "values written out in ASCII",
  "case-insenstive hexadecimal encoding (2 chars / byte)",
  "gzip compression of binary encoding",
  "bzip2 compression of binary encoding",
}

char _nrrdEncodingTypeStr[NRRD_ENCODING_TYPE_MAX+1][AIR_STRLEN_SMALL]

Initial value:

 {
  "(unknown_encoding)",
  "raw",
  "ascii",
  "hex",
  "gz",
  "bz2",
}

char _nrrdEncodingTypeStrEqv[][AIR_STRLEN_SMALL]

Initial value:

 {
  "(unknown_encoding)",
  "raw",
  "txt", "text", "ascii",
  "hex",
  "gz", "gzip",
  "bz2", "bzip2",
  ""
}

Initial value:

 {
  nrrdEncodingTypeUnknown,
  nrrdEncodingTypeRaw,
  nrrdEncodingTypeAscii, nrrdEncodingTypeAscii, nrrdEncodingTypeAscii,
  nrrdEncodingTypeHex,
  nrrdEncodingTypeGzip, nrrdEncodingTypeGzip,
  nrrdEncodingTypeBzip2, nrrdEncodingTypeBzip2,
}

char _nrrdFieldDesc[NRRD_FIELD_MAX+1][AIR_STRLEN_MED]

char _nrrdFieldStr[NRRD_FIELD_MAX+1][AIR_STRLEN_SMALL]

char _nrrdFieldStrEqv[][AIR_STRLEN_SMALL]

char _nrrdFormatTypeDesc[NRRD_FORMAT_TYPE_MAX+1][AIR_STRLEN_MED]

Initial value:

 {
  "unknown_format",
  "native format for nearly raw raster data",
  "Portable aNy Map: includes PGM for grayscale and PPM for color",
  "Portable Network Graphics: lossless compression of 8- and 16-bit data",
  "Visualization ToolKit STRUCTURED_POINTS data",
  "white-space-delimited plain text encoding of 2-D float array",
  "Encapsulated PostScript images",
}

char _nrrdFormatTypeStr[NRRD_FORMAT_TYPE_MAX+1][AIR_STRLEN_SMALL]

Initial value:

 {
  "(unknown_format)",
  "nrrd",
  "pnm",
  "png",
  "vtk",
  "text",
  "eps",
}

char _nrrdFormatTypeStrEqv[][AIR_STRLEN_SMALL]

Initial value:

 {
  "nrrd",
  "pnm",
  "png",
  "vtk",
  "table", "text", "txt",
  "eps",
  ""
}

Initial value:

char _nrrdKindDesc[NRRD_KIND_MAX+1][AIR_STRLEN_MED]

char _nrrdKindStr[NRRD_KIND_MAX+1][AIR_STRLEN_SMALL]

char _nrrdKindStr_Eqv[][AIR_STRLEN_SMALL]

char _nrrdMeasureDesc[NRRD_MEASURE_MAX+1][AIR_STRLEN_MED]

Initial value:

 {
  "unknown measure",
  "minimum of values",
  "maximum of values",
  "mean of values",
  "median of values",
  "mode of values",
  "product of values",
  "sum of values",
  "L1 norm of values",
  "L2 norm of values",
  "Linf norm of values",
  "variance of values",
  "standard deviation of values",
  "skew of values",
  "slope of line of best fit",
  "y-intercept of line of best fit",
  "error of line fitting",
  "minimum of histogrammed values",
  "maximum of histogrammed values",
  "mean of histogrammed values",
  "median of histogrammed values",
  "mode of histogrammed values",
  "product of histogrammed values",
  "sum of histogrammed values",
  "L2 norm of histogrammed values",
  "variance of histogrammed values",
  "standard deviation of histogrammed values",
}

char _nrrdMeasureStr[NRRD_MEASURE_MAX+1][AIR_STRLEN_SMALL]

Initial value:

 {
  "(unknown_measure)",
  "min",
  "max",
  "mean",
  "median",
  "mode",
  "product",
  "sum",
  "L1",
  "L2",
  "Linf",
  "variance",
  "SD",
  "skew",
  "line-slope",
  "line-intercept",
  "line-error",
  "histo-min",
  "histo-max",
  "histo-mean",
  "histo-median",
  "histo-mode",
  "histo-product",
  "histo-sum",
  "histo-L2",
  "histo-variance",
  "histo-SD",
}

char _nrrdMeasureStrEqv[][AIR_STRLEN_SMALL]

Initial value:

 {
  "(unknown_measure)",
  "min",
  "max",
  "mean",
  "median",
  "mode",
  "product", "prod",
  "sum",
  "L1",
  "L2",
  "Linf",
  "variance", "var",
  "SD", "stdv",
  "skew", "skewness",
  "slope", "line-slope",
  "intc", "intercept", "line-intc", "line-intercept",
  "error", "line-error",
  "histo-min",
  "histo-max",
  "histo-mean",
  "histo-median",
  "histo-mode",
  "histo-product",
  "histo-sum",
  "histo-l2",
  "histo-variance", "histo-var",
  "histo-sd",
  ""
}

char _nrrdSpaceDesc[NRRD_SPACE_MAX+1][AIR_STRLEN_MED]

Initial value:

 {
  "unknown space",
  "right-anterior-superior (used in NIFTI-1 and SPL's 3D Slicer)",
  "left-anterior-superior (used in Analyze 7.5)",
  "left-posterior-superior (used in DICOM 3)",
  "right-anterior-superior-time",
  "left-anterior-superior-time",
  "left-posterior-superior-time",
  "scanner-xyz (used in ACR/NEMA 2.0)",
  "scanner-xyz-time",
  "3D-right-handed",
  "3D-left-handed",
  "3D-right-handed-time",
  "3D-left-handed-time",
}

char _nrrdSpaceStr[NRRD_SPACE_MAX+1][AIR_STRLEN_SMALL]

Initial value:

 {
  "(unknown_space)",
  "right-anterior-superior",
  "left-anterior-superior",
  "left-posterior-superior",
  "right-anterior-superior-time",
  "left-anterior-superior-time",
  "left-posterior-superior-time",
  "scanner-xyz",
  "scanner-xyz-time",
  "3D-right-handed",
  "3D-left-handed",
  "3D-right-handed-time",
  "3D-left-handed-time",
}

char _nrrdSpaceStrEqv[][AIR_STRLEN_SMALL]

Initial value:

 {
  "(unknown_space)",
  "right-anterior-superior", "right anterior superior",
      "rightanteriorsuperior", "RAS",
  "left-anterior-superior", "left anterior superior",
      "leftanteriorsuperior", "LAS",
  "left-posterior-superior", "left posterior superior",
      "leftposteriorsuperior", "LPS",
  "right-anterior-superior-time", "right anterior superior time",
      "rightanteriorsuperiortime", "RAST",
  "left-anterior-superior-time", "left anterior superior time",
      "leftanteriorsuperiortime", "LAST",
  "left-posterior-superior-time", "left posterior superior time",
      "leftposteriorsuperiortime", "LPST",
  "scanner-xyz",
  "scanner-xyz-time", "scanner-xyzt", 
  "3D-right-handed", "3D right handed", "3Drighthanded"
  "3D-left-handed", "3D left handed", "3Dlefthanded",
  "3D-right-handed-time", "3D right handed time",
      "3Drighthandedtime",
  "3D-left-handed-time", "3D left handed time",
      "3Dlefthandedtime",
  ""
}

Initial value:

 {
  nrrdSpaceUnknown,
  nrrdSpaceRightAnteriorSuperior, nrrdSpaceRightAnteriorSuperior,
     nrrdSpaceRightAnteriorSuperior, nrrdSpaceRightAnteriorSuperior,
  nrrdSpaceLeftAnteriorSuperior, nrrdSpaceLeftAnteriorSuperior,
     nrrdSpaceLeftAnteriorSuperior, nrrdSpaceLeftAnteriorSuperior,
  nrrdSpaceLeftPosteriorSuperior, nrrdSpaceLeftPosteriorSuperior,
     nrrdSpaceLeftPosteriorSuperior, nrrdSpaceLeftPosteriorSuperior,
  nrrdSpaceRightAnteriorSuperiorTime, nrrdSpaceRightAnteriorSuperiorTime,
     nrrdSpaceRightAnteriorSuperiorTime, nrrdSpaceRightAnteriorSuperiorTime,
  nrrdSpaceLeftAnteriorSuperiorTime, nrrdSpaceLeftAnteriorSuperiorTime,
     nrrdSpaceLeftAnteriorSuperiorTime, nrrdSpaceLeftAnteriorSuperiorTime,
  nrrdSpaceLeftPosteriorSuperiorTime, nrrdSpaceLeftPosteriorSuperiorTime,
     nrrdSpaceLeftPosteriorSuperiorTime, nrrdSpaceLeftPosteriorSuperiorTime,
  nrrdSpaceScannerXYZ,
  nrrdSpaceScannerXYZTime, nrrdSpaceScannerXYZTime, 
  nrrdSpace3DRightHanded, nrrdSpace3DRightHanded, nrrdSpace3DRightHanded,
  nrrdSpace3DLeftHanded, nrrdSpace3DLeftHanded, nrrdSpace3DLeftHanded,
  nrrdSpace3DRightHandedTime, nrrdSpace3DRightHandedTime, 
     nrrdSpace3DRightHandedTime,
  nrrdSpace3DLeftHandedTime, nrrdSpace3DLeftHandedTime,
     nrrdSpace3DLeftHandedTime
}

char _nrrdTernaryOpDesc[NRRD_TERNARY_OP_MAX+1][AIR_STRLEN_MED]

Initial value:

 {
  "unknown ternary op",
  "add three values",
  "multiply three values",
  "minimum of three values",
  "maximum of three values",
  "clamp 2nd value to closed interval between 1st and 3rd",
  "if 1st value is non-zero, then 2nd value, else 3rd value",
  "linearly interpolate between 2nd value (1st = 0.0) and 3rd (1st = 1.0)",
  "if 1st value exists, the 2nd value, else the 3rd",
  "2nd value is inside OPEN interval range between 1st and 3rd",
  "2nd value is inside CLOSED interval range between 1st and 3rd",
}

char _nrrdTernaryOpStr[NRRD_TERNARY_OP_MAX+1][AIR_STRLEN_SMALL]

Initial value:

 {
  "(unknown_ternary_op)",
  "add",
  "multiply",
  "min",
  "max",
  "clamp",
  "ifelse",
  "lerp",
  "exists",
  "in_op",
  "in_cl",
}

char _nrrdTernaryOpStrEqv[][AIR_STRLEN_SMALL]

Initial value:

 {
  "+", "plus", "add",
  "x", "*", "times", "multiply", "product",
  "min",
  "max",
  "clamp",
  "ifelse", "if",
  "lerp",
  "exists",
  "in_op",
  "in_cl",
  ""
}

char _nrrdTypeDesc[NRRD_TYPE_MAX+1][AIR_STRLEN_MED]

Initial value:

 {
  "unknown type",
  "signed 1-byte integer",
  "unsigned 1-byte integer",
  "signed 2-byte integer",
  "unsigned 2-byte integer",
  "signed 4-byte integer",
  "unsigned 4-byte integer",
  "signed 8-byte integer",
  "unsigned 8-byte integer",
  "4-byte floating point",
  "8-byte floating point",
  "size user-defined at run-time",
}

char _nrrdTypeStr[NRRD_TYPE_MAX+1][AIR_STRLEN_SMALL]

Initial value:

 {
  "(unknown_type)",
  "signed char",
  "unsigned char",
  "short",
  "unsigned short",
  "int",
  "unsigned int",
  "long long int",
  "unsigned long long int",
  "float",
  "double",
  "block",
}

char _nrrdTypeStrEqv[][AIR_STRLEN_SMALL]

Initial value:

 {
  "signed char",  "int8", "int8_t",
  "uchar", "unsigned char", "uint8", "uint8_t", 
  "short", "short int", "signed short", "signed short int", "int16", "int16_t",
  "ushort", "unsigned short", "unsigned short int", "uint16", "uint16_t", 
  "int", "signed int", "int32", "int32_t", 
  "uint", "unsigned int", "uint32", "uint32_t",
  "longlong", "long long", "long long int", "signed long long",
               "signed long long int", "int64", "int64_t", 
  "ulonglong", "unsigned long long", "unsigned long long int",
               "uint64", "uint64_t", 
  "float",
  "double",
  "block",
  ""
}

Initial value:

 {
  ntCH, ntCH, ntCH,
  ntUC, ntUC, ntUC, ntUC,
  ntSH, ntSH, ntSH, ntSH, ntSH, ntSH,
  ntUS, ntUS, ntUS, ntUS, ntUS,
  ntIN, ntIN, ntIN, ntIN,
  ntUI, ntUI, ntUI, ntUI, 
  ntLL, ntLL, ntLL, ntLL, ntLL, ntLL, ntLL, 
  ntUL, ntUL, ntUL, ntUL, ntUL, 
  ntFL,
  ntDB,
  ntBL,
}

char _nrrdUnaryOpDesc[NRRD_UNARY_OP_MAX+1][AIR_STRLEN_MED]

char _nrrdUnaryOpStr[NRRD_UNARY_OP_MAX+1][AIR_STRLEN_SMALL]

char _nrrdUnaryOpStrEqv[][AIR_STRLEN_SMALL]

Initial value:

 {
  nuNeg, nuNeg, nuNeg, nuNeg,
  nuRcp, nuRcp,
  nuSin,
  nuCos,
  nuTan,
  nuAsn, nuAsn,
  nuAcs, nuAcs,
  nuAtn, nuAtn,
  nuExp,
  nuLge, nuLge,
  nuLg2,
  nuLgt,
  nuL1p, nuL1p,
  nuSqt,
  nuCbt,
  nuErf,
  nuCil,
  nuFlr,
  nuRup, nuRup,
  nuRdn, nuRdn, nuRdn,
  nuAbs, nuAbs,
  nuSgn, nuSgn,
  nuExs,
  nuRnd,
  nuNrn, nuNrn, nuNrn,
  nuoIf,
  nuZer, nuZer,
  nuOne, nuOne
}


Generated on Sat May 9 03:55:31 2009 for Teem by  doxygen 1.5.9