/usr/include/minc2_structs.h is in libminc-dev 2.3.00-5.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 | /** internal minc2 data structures*/
#ifndef MINC2_STRUCTS_H
#define MINC2_STRUCTS_H
#include "H5public.h"
/************************************************************************
* ENUMS, STRUCTS, and TYPEDEFS
************************************************************************/
/* These structure declarations exist to allow the following typedefs to
* work. Since the details of these structures are not meant to be public,
* the actual structure definitions are in minc2_private.h
*/
struct mivolprops;
struct midimension;
struct mivolume;
/** \typedef mivolumeprops_t
* Opaque pointer to volume properties.
*/
typedef struct mivolprops *mivolumeprops_t;
/** \typedef midimhandle_t
* Opaque pointer to a MINC dimension object.
*/
typedef struct midimension *midimhandle_t;
/** \typedef mihandle_t
* The mihandle_t is an opaque type that represents a MINC file object.
*/
typedef struct mivolume *mihandle_t;
/** \typedef milisthandle_t
* The milisthandle_t is an opaque type that represents a handle
* to iterate through various properties of MINC file object.
*/
typedef void *milisthandle_t;
/**
* This typedef used to represent the type of an individual voxel <b>as
* stored</b> by MINC 2.0.
*/
typedef enum {
MI_TYPE_ORIGINAL = 0, /**< MI_ORIGINAL_TYPE */
MI_TYPE_BYTE = 1, /**< 8-bit signed integer */
MI_TYPE_SHORT = 3, /**< 16-bit signed integer */
MI_TYPE_INT = 4, /**< 32-bit signed integer */
MI_TYPE_FLOAT = 5, /**< 32-bit floating point */
MI_TYPE_DOUBLE = 6, /**< 64-bit floating point */
MI_TYPE_STRING = 7, /**< ASCII string */
MI_TYPE_UBYTE = 100, /**< 8-bit unsigned integer */
MI_TYPE_USHORT = 101, /**< 16-bit unsigned integer */
MI_TYPE_UINT = 102, /**< 32-bit unsigned integer */
MI_TYPE_SCOMPLEX = 1000, /**< 16-bit signed integer complex */
MI_TYPE_ICOMPLEX = 1001, /**< 32-bit signed integer complex */
MI_TYPE_FCOMPLEX = 1002, /**< 32-bit floating point complex */
MI_TYPE_DCOMPLEX = 1003, /**< 64-bit floating point complex */
MI_TYPE_UNKNOWN = -1 /**< when the type is a record */
} mitype_t;
/** \typedef miclass_t
* This typedef is used to represent the class of the MINC file.
*
* The class specifies the data's interpretation rather than its
* storage format. For example, a floating point class implies
* that the data may be stored as integers but must nonetheless be
* scaled into a "real" range before any mathematical operations
* are performed. A label class implies that the values of a voxel
* should be considered to represent a symbol, and therefore many
* operations on the voxels would be considered meaningless.
*/
typedef enum {
MI_CLASS_REAL = 0, /**< Floating point (default) */
MI_CLASS_INT = 1, /**< Integer */
MI_CLASS_LABEL = 2, /**< Enumerated (named data values) */
MI_CLASS_COMPLEX = 3, /**< Complex (real/imaginary) values */
MI_CLASS_UNIFORM_RECORD = 4, /**< Aggregate datatypes consisting of multiple values of the same underlying type. */
MI_CLASS_NON_UNIFORM_RECORD = 5 /**< Aggregate datatypes consisting of multiple values of potentially differing types (not yet implemented). */
} miclass_t;
/** \typedef midimclass_t
* Dimensions be members of one of several classes. The "MI_DIMCLASS_ANY"
* value is never actually assigned to a dimension. It is used in the
* programming interface to specify that an operation should apply to
* all dimensions regardless of class.
*/
typedef enum {
MI_DIMCLASS_ANY = 0, /**< Don't care (or unknown) */
MI_DIMCLASS_SPATIAL = 1, /**< Spatial dimensions (x, y, z) */
MI_DIMCLASS_TIME = 2, /**< Time dimension */
MI_DIMCLASS_SFREQUENCY = 3, /**< Spatial frequency dimensions */
MI_DIMCLASS_TFREQUENCY = 4, /**< Temporal frequency dimensions */
MI_DIMCLASS_USER = 5, /**< Arbitrary user-defined dimension */
MI_DIMCLASS_RECORD = 6 /**< Record as dimension */
} midimclass_t;
/** \typedef miorder_t
* Dimension order refers to the idea that data can be structured in
* a variety of ways with respect to the dimensions. For example, a typical
* 3D scan could be structured as a transverse (ZYX) or sagittal (XZY) image.
* Since it may be convenient to write code which expects a particular
* dimension order, a user can specify an alternative ordering by using
* miset_apparent_dimension_order(). This will cause most functions
* to return data as if the file was in the apparent, rather than the
* file (native) order.
*/
typedef enum {
MI_DIMORDER_FILE = 0,
MI_DIMORDER_APPARENT = 1
} miorder_t;
/** \typedef mivoxel_order_t
* Voxel order can be either file (native), or apparent, as set by
* the function miset_dimension_apparent_voxel_order().
*/
typedef enum {
MI_ORDER_FILE = 0, /**< File order */
MI_ORDER_APPARENT = 1 /**< Apparent (user) order */
} mivoxel_order_t;
/** \typedef miflipping_t
* Voxel flipping can be specified to either follow the file's native
* order, the opposite of the file's order, or it can be tied to the
* value of the dimension's step attribute. A value of MI_NEGATIVE
* implies that the voxel order should be rearranged such that the step
* attribute is negative, a value of MI_POSITIVE implies the opposite.
*/
typedef enum {
MI_FILE_ORDER = 0, /**< no flip */
MI_COUNTER_FILE_ORDER = 1, /**< flip */
MI_POSITIVE = 2, /**< force step value to be positive */
MI_NEGATIVE = 3 /**< force step value to be negative */
} miflipping_t;
/** \typedef micompression_t
* Compression type
*/
typedef enum {
MI_COMPRESS_NONE = 0, /**< No compression */
MI_COMPRESS_ZLIB = 1 /**< GZIP compression */
} micompression_t;
/** \typedef miboolean_t
* Boolean value
*/
typedef int miboolean_t;
/** \typedef midimattr_t
* Something about dimension attributes
*/
typedef unsigned int midimattr_t;
/** \typedef misize_t
* size of things
*/
typedef hsize_t misize_t; /*based on HDF5 size*/
/** \typedef miscomplex_t
* 16-bit integer complex voxel.
*/
typedef struct {
short real; /**< Real part */
short imag; /**< Imaginary part */
} miscomplex_t;
/** \typedef miicomplex_t
* 32-bit integer complex voxel.
*/
typedef struct {
int real; /**< Real part */
int imag; /**< Imaginary part */
} miicomplex_t;
/** \typedef mifcomplex_t
* 32-bit floating point complex voxel.
*/
typedef struct {
float real; /**< Real part */
float imag; /**< Imaginary part */
} mifcomplex_t;
/** \typedef midcomplex_t
* 64-bit floating point complex voxel.
*/
typedef struct {
double real; /**< Real part */
double imag; /**< Imaginary part */
} midcomplex_t;
#endif //MINC2_STRUCTS_H
|