SCM Repository

[diderot] Diff of /branches/vis12/src/lib/common/dyn-seq.c

[diderot] / branches / vis12 / src / lib / common / dyn-seq.c

Diff of /branches/vis12/src/lib/common/dyn-seq.c

-revision 1977, Mon Jul 16 20:04:34 2012 UTC
+revision 1978, Sat Jul 21 16:19:40 2012 UTC
 Line 11
   */
  #include "Diderot/diderot.h"
+ #include <teem/nrrd.h>
  // compute the address of the i'th element in the sequence
  STATIC_INLINE void* ElemAddr(void *base, size_t elemSz, unsigned int i)
-Line 66
+Line 67
          return (void *)((char *)dst + cpySz);
      }
  }
+ static struct {
+     bool isFloat;
+     unsigned int sizeb;
+ } NrrdTypeInfo[nrrdTypeLast] = {
+         [nrrdTypeDefault] = {false, 0},         /*  0: signifies "determine output type for me" */
+         [nrrdTypeChar] = {false, 1},            /*  1:   signed 1-byte integer */
+         [nrrdTypeUChar] = {false, 1},           /*  2: unsigned 1-byte integer */
+         [nrrdTypeShort] = {false, 2},           /*  3:   signed 2-byte integer */
+         [nrrdTypeUShort] = {false, 2},          /*  4: unsigned 2-byte integer */
+         [nrrdTypeInt] = {false, 4},             /*  5:   signed 4-byte integer */
+         [nrrdTypeUInt] = {false, 4},            /*  6: unsigned 4-byte integer */
+         [nrrdTypeLLong] = {false, 8},           /*  7:   signed 8-byte integer */
+         [nrrdTypeULLong] = {false, 8},          /*  8: unsigned 8-byte integer */
+         [nrrdTypeFloat] = {true, 4},            /*  9:          4-byte floating point */
+         [nrrdTypeDouble] = {true, 8},           /* 10:          8-byte floating point */
+         [nrrdTypeBlock] = {false, 0},           /* 11: size user defined at run time; MUST BE LAST */
+     };
+ //! Check that a nrrd has the expected structure for loading into a dynamic sequence
+ //! \param wrld the world; used to report errors
+ //! \param nin the nrrd to check
+ //! \param nDims the number of dimensions in the sequence elements
+ //! \param dims the array of sequence element dimensions
+ //! \return the number of values per element, or zero on error
+ static unsigned int CheckNrrd (
+     WorldPrefix_t *wrld,
+     Nrrd *nin,
+     unsigned int nDims,
+     unsigned int *dims)
+ {
+   // compute the expected number of values per sequence element
+     unsigned int nValuesPerElem = 1;
+     for (unsigned int i = 0;  i < nDims;  i++) {
+         nValuesPerElem *= dims[i];
+     }
+   // check the structure of the nrrd file
+     if (nin->spaceDim != 1) {
+         Diderot_Error (wrld, "unexpected number of axes in nrrd; expected 1, found %d\n",
+             nin->spaceDim);
+         return 0;
+     }
+     if (nin->dim - 1 != nDims) {
+         Diderot_Error (wrld, "unexpected nrrd dimension; expected %d, found %d\n",
+             nDims, nin->dim-1);
+         return 0;
+     }
+     for (unsigned int i = 0;  i < nDims;  i++) {
+         if (dims[i] != nin->axis[i+1].size) {
+             Diderot_Error (wrld, "nrrd shape does not match expected structure\n");
+             return 0;
+         }
+     }
+     if (NrrdTypeInfo[nin->type].size == 0) {
+         Diderot_Error (wrld, "bogus element type %d in nrrd\n", nin->type);
+         return 0;
+     }
+     return nValuesPerElem;
+ }
+ //! load a dynamic sequence from a Nrrd file, where the sequence elements have real ground type.
+ //! \param wrld the world; used to report errors
+ //! \param nin the nrrd to check
+ //! \param nDims the number of dimensions in the sequence elements
+ //! \param dims the array of sequence element dimensions
+ //! \return the dynamic sequence, or zero on error
+ Diderot_DynSeq_t *Diderot_DynSeqLoadReal (
+     WorldPrefix_t *wrld,
+     Nrrd *nin,
+     unsigned int nDims,
+     unsigned int *dims)
+ {
+     unsigned int nValuesPerElem = CheckNrrd(wrld, nin, nDims, dims);
+     size_t elemSz = SIZEOF_DIDEROT_REAL * nValuesPerElem;
+     if (nValuesPerElem == 0)
+         return (Diderot_DynSeq_t *)0;
+   // get the number of elements
+     size_t nElems = nin->axis[0].size;
+   // allocate the dynamic sequence
+     Diderot_DynSeq_t *seq = Diderot_DynSeqAlloc(elemSz, nElems);
+   // initialize the sequence from the nrrd
+     if (! nrrdTypeInfo[nin->type].isFloat || (nrrdTypeInfo[nin->type].size != SIZEOF_DIDEROT_REAL)) {
+       // this is the slow path; we have to convert values as they are copied from the nrrd
+ #if defined(DIDEROT_DOUBLE_PRECISION)
+         double (*loadFn)(const void *) = nrrdDLoad[nin->type];
+ #else
+         float (*loadFn)(const void *) = nrrdFLoad[nin->type];
+ #endif
+         Diderot_real_t *dst = (Diderot_real_t *)seq->data;
+         char *src = (char *)nin->data;
+         size_t srcElemSz = NrrdTypeInfo[nin->type].size;
+         for (size_t i = 0;  i < nElems * nValuesPerElem;  i++) {
+             *dst++ = loadFn(src);
+             src += srcElemSz;
+         }
+     }
+     else {
+       // this is the fast path, where we can just do a bulk memcpy
+         memcpy (seq->data, nin->data, nElems * elemSz);
+     }
+     return seq;
+ }
+ //! load a dynamic sequence from a Nrrd file, where the sequence elements have int ground type.
+ //! \param wrld the world; used to report errors
+ //! \param nin the nrrd to check
+ //! \param nDims the number of dimensions in the sequence elements
+ //! \param dims the array of sequence element dimensions
+ //! \return the dynamic sequence, or zero on error
+ Diderot_DynSeq_t *Diderot_DynSeqLoadInt (
+     WorldPrefix_t *wrld,
+     Nrrd *nin,
+     unsigned int nDims,
+     unsigned int *dims)
+ {
+     unsigned int nValuesPerElem = CheckNrrd(wrld, nin, nDims, dims);
+     size_t elemSz = SIZEOF_DIDEROT_INT * nValuesPerElem;
+     if (nValuesPerElem == 0)
+         return (Diderot_DynSeq_t *)0;
+     if (nrrdTypeInfo[nin->type].isFloat) {
+         Diderot_Error (wrld, "expected integer element type for int sequence, but found %d\n", nin->type);
+         return 0;
+     }
+   // get the number of elements
+     size_t nElems = nin->axis[0].size;
+   // allocate the dynamic sequence
+     Diderot_DynSeq_t *seq = Diderot_DynSeqAlloc(elemSz, nElems);
+   // initialize the sequence from the nrrd
+     if (nrrdTypeInfo[nin->type].size != SIZEOF_DIDEROT_INT) {
+       // this is the slow path; we have to convert values as they are copied from the nrrd
+         int (*loadFn)(const void *) = nrrdILoad[nin->type];
+         Diderot_int_t *dst = (Diderot_int_t *)seq->data;
+         char *src = (char *)nin->data;
+         size_t srcElemSz = NrrdTypeInfo[nin->type].size;
+         for (size_t i = 0;  i < nElems * nValuesPerElem;  i++) {
+             *dst++ = loadFn(src);
+             src += srcElemSz;
+         }
+     }
+     else {
+       // this is the fast path, where we can just do a bulk memcpy
+         memcpy (seq->data, nin->data, nElems * elemSz);
+     }
+     return seq;
+ }
+ //! load a dynamic sequence from a Nrrd file, where the sequence elements have bool ground type.
+ //! \param wrld the world; used to report errors
+ //! \param nin the nrrd to check
+ //! \param nDims the number of dimensions in the sequence elements
+ //! \param dims the array of sequence element dimensions
+ //! \return the dynamic sequence, or zero on error
+ Diderot_DynSeq_t *Diderot_DynSeqLoadBool (
+     WorldPrefix_t *wrld,
+     Nrrd *nin,
+     unsigned int nDims,
+     unsigned int *dims)
+ {
+     unsigned int nValuesPerElem = CheckNrrd(wrld, nin, nDims, dims);
+     size_t elemSz = SIZEOF_DIDEROT_BOOL * nValuesPerElem;
+     if (nValuesPerElem == 0)
+         return (Diderot_DynSeq_t *)0;
+     if (nrrdTypeInfo[nin->type].isFloat) {
+         Diderot_Error (wrld, "expected integer element type for bool sequence, but found %d\n", nin->type);
+         return 0;
+     }
+   // get the number of elements
+     size_t nElems = nin->axis[0].size;
+   // allocate the dynamic sequence
+     Diderot_DynSeq_t *seq = Diderot_DynSeqAlloc(elemSz, nElems);
+   // initialize the sequence from the nrrd
+     if (nrrdTypeInfo[nin->type].size != sizeof(bool)) {
+       // this is the slow path; we have to convert values as they are copied from the nrrd
+         int (*loadFn)(const void *) = nrrdILoad[nin->type];
+         bool *dst = (bool *)seq->data;
+         char *src = (char *)nin->data;
+         size_t srcElemSz = NrrdTypeInfo[nin->type].size;
+         for (size_t i = 0;  i < nElems * nValuesPerElem;  i++) {
+             *dst++ = loadFn(src) ? true : false;
+             src += srcElemSz;
+         }
+     }
+     else {
+       // this is the fast path, where we can just do a bulk memcpy
+         memcpy (seq->data, nin->data, nElems * elemSz);
+     }
+     return seq;
+ }

 Legend:



Removed from v.1977
 


changed lines


 
Added in v.1978
 Legend:



Removed from v.1977
 


changed lines


 
Added in v.1978
-Removed from v.1977
+Added in v.1978

root@smlnj-gforge.cs.uchicago.edu	ViewVC Help
Powered by ViewVC 1.0.0