754.c

/Users/scm/git/github/teem/src/air/array.c

/Users/scm/git/github/teem/src/air/dio.c

/Users/scm/git/github/teem/src/air/endianAir.c

/Users/scm/git/github/teem/src/air/enum.c

/Users/scm/git/github/teem/src/air/heap.c

1 /* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2010 Thomas Schultz This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "air.h" #include <string.h> /* internal helper routines */ /* restore heap property by pulling a single node up the tree */ 27 static void upheap( airHeap *h, unsigned int i ) { while ( i ) { unsigned int parent = ( i-1 )/2; if ( h->key[h->idx[parent]] > h->key[h->idx[i]] ) { /* swap */ unsigned int tmp = h->idx[parent]; h->idx[parent] = h->idx[i]; h->idx[i] = tmp; h->invidx[h->idx[i]] = i; h->invidx[h->idx[parent]] = parent; i = parent; } else i = 0; /* break loop */ } } /* restore heap property by pushing a single node down the tree */ 43 static void downheap ( airHeap *h, unsigned int i ) { unsigned int len = h->key_a->len; while ( 1 ) { unsigned int left = 2*i+1; unsigned int right = 2*i+2; unsigned int minidx = 0; double minval = 0; if ( left>=len ) return; if ( ( right>=len ) || ( h->key[h->idx[left]] < h->key[h->idx[right]] ) ) { minidx = left; minval = h->key[h->idx[left]]; } else { minidx = right; minval = h->key[h->idx[right]]; } if ( h->key[h->idx[i]] > minval ) { /* swap */ unsigned int tmp = h->idx[i]; h->idx[i] = h->idx[minidx]; h->idx[minidx] = tmp; h->invidx[h->idx[i]] = i; h->invidx[h->idx[minidx]] = minidx; i = minidx; } else return; } } /* Restore heap property "from scratch" ( without any prior assumptions ). * Works in a bottom-up manner, which is more efficient than top-down */ 74 static void heapify ( airHeap *h ) { unsigned int len = h->key_a->len; int maxi = len/2-1, i; /* above maxi, downheap has no effect */ for ( i=maxi; i>=0; i-- ) { downheap( h, i ); } } /* Tries to increase or decrease the length of h. returns 0 upon success. */ 83 static int heapLenIncr ( airHeap *h, int delta ) { unsigned int oldlen=h->key_a->len; unsigned int newlen=oldlen+delta; if ( delta==0 ) return 0; airArrayLenIncr( h->key_a, delta ); if ( h->data_a!=NULL ) airArrayLenIncr( h->data_a, delta ); airArrayLenIncr( h->idx_a, delta ); airArrayLenIncr( h->invidx_a, delta ); if ( h->key_a->len<newlen || ( h->data_a!=NULL && h->data_a->len<newlen ) || h->idx_a->len<newlen || h->invidx_a->len<newlen ) { /* Error. Try to undo changes and return error code. */ if ( h->key_a->len>oldlen ) airArrayLenSet( h->key_a, oldlen ); if ( h->data_a!=NULL && h->data_a->len>oldlen ) airArrayLenSet( h->data_a, oldlen ); if ( h->idx_a->len>oldlen ) airArrayLenSet( h->idx_a, oldlen ); if ( h->invidx_a->len>oldlen ) airArrayLenSet( h->invidx_a, oldlen ); return 1; } return 0; } /* Creates a new heap, returning NULL upon error. If additional data * is to be stored with each node, dataUnit needs to be set to the * number of data bytes needed per element. incr is used for dynamic * memory allocation ( an additional number of incr elements are * allocated each time the heap grows past its current capacity ). */ 111 airHeap *airHeapNew( size_t dataUnit, unsigned int incr ) { airHeap *h; airPtrPtrUnion appu; h = AIR_CALLOC( 1, airHeap ); if ( h==NULL ) { return NULL; } appu.d = &h->key; h->key_a = airArrayNew( appu.v, NULL, sizeof( double ), incr ); if ( dataUnit>0 ) { /* data is optional */ h->data_a = airArrayNew( &h->data, NULL, dataUnit, incr ); } appu.ui = &h->idx; h->idx_a = airArrayNew( appu.v, NULL, sizeof( unsigned int ), incr ); appu.ui = &h->invidx; h->invidx_a = airArrayNew( appu.v, NULL, sizeof( unsigned int ), incr ); if ( h->key_a==NULL || ( dataUnit>0 && h->data_a==NULL ) || h->idx_a==NULL || h->invidx_a==NULL ) { /* allocation failed ( partly ) */ airHeapNix( h ); return NULL; } return h; } /* Same as airHeapNew, but initializes the new heap with the keys from key * and the optional data from data. If data is non-NULL, it needs to * have the same length as key, or this function will fail. The incr * field of the heap is copied from key ( rather than data ). */ 142 airHeap *airHeapFromArray( const airArray *key, const airArray *data ) { airHeap *h; unsigned int i; if ( key==NULL || ( data!=NULL && data->len!=key->len ) ) return NULL; /* unusable input */ h = airHeapNew( ( data==NULL )?0:data->unit, key->incr ); if ( heapLenIncr ( h, key->len ) ) { /* could not allocate memory */ airHeapNix( h ); return NULL; } memcpy( h->key, key->data, key->len*sizeof( double ) ); if ( h->data_a!=NULL ) memcpy( h->data, data->data, data->len*data->unit ); for ( i=0; i<key->len; i++ ) { /* initialize indices to identity */ h->idx[i]=i; h->invidx[i]=i; } heapify( h ); return h; } /* Frees all memory associated with the heap and its data */ 163 airHeap *airHeapNix( airHeap *h ) { if ( h!=NULL ) { airArrayNuke( h->key_a ); if ( h->data_a!=NULL ) airArrayNuke( h->data_a ); airArrayNuke( h->idx_a ); airArrayNuke( h->invidx_a ); free( h ); } return NULL; } /* Returns the number of elements that are currently in heap h * ( or 0 if h==NULL ) */ 176 unsigned int airHeapLength( const airHeap *h ) { if ( h!=NULL ) { return h->key_a->len; } else return 0; } /* Inserts a key into the heap. data is copied over ( deep copy ) when the * heap was initialized to hold additional data. Otherwise, it is ignored. * * Returns the new number of elements in h. * Upon error, this can be the same as the old length. */ 188 unsigned int airHeapInsert( airHeap *h, double key, const void *data ) { unsigned int oldlen; if ( h==NULL ) return 0; oldlen = h->key_a->len; /* make space for the new element */ if ( heapLenIncr( h, 1 ) ) return oldlen; h->key[oldlen]=key; if ( h->data_a!=NULL && data!=NULL ) { memcpy( ( char* )h->data_a->data+oldlen*h->data_a->unit, data, h->data_a->unit ); } h->idx[oldlen]=oldlen; h->invidx[oldlen]=oldlen; upheap( h, oldlen ); /* restore the heap property */ return oldlen+1; } /* Merges the second heap into the first. Returns the new length of first, * or zero upon error. */ 208 unsigned int airHeapMerge( airHeap *first, const airHeap *second ) { unsigned int first_len, second_len, i; if ( first==NULL || second==NULL ) return 0; if ( ( first->data_a==NULL ) ^ ( second->data_a==NULL ) ) return 0; /* incompatible data */ if ( first->data_a!=NULL && ( first->data_a->unit!=second->data_a->unit ) ) return 0; /* incompatible data */ /* make sufficient space in first */ first_len = first->key_a->len; second_len = second->key_a->len; if ( heapLenIncr( first, second_len ) ) return 0; /* concatenate and heapify */ memcpy( first->key+first_len, second->key, second_len*sizeof( double ) ); if ( first->data_a!=NULL ) memcpy( ( char* )first->data_a->data+first_len*first->data_a->unit, second->data_a->data, second_len*second->data_a->unit ); for ( i=0; i<second_len; i++ ) { first->idx[first_len+i] = first_len+second->idx[i]; first->invidx[first->idx[first_len+i]]=first_len+i; } heapify( first ); return first_len+second_len; } /* Returns the key of the front element in the heap and optionally copies the * associated data to *data. Does not modify the heap. */ 237 double airHeapFrontPeek( const airHeap *h, void *data ) { if ( h==NULL || h->key_a->len==0 ) return 0.0; if ( data!=NULL && h->data_a!=NULL ) memcpy( data, ( char* )h->data_a->data+h->idx[0]*h->data_a->unit, h->data_a->unit ); return h->key[h->idx[0]]; } /* Same as airHeapFrontPeek, but additionally removes the front element. */ 247 double airHeapFrontPop( airHeap *h, void *data ) { double retval = airHeapFrontPeek( h, data ); if ( h!=NULL && h->key_a->len>0 ) { airHeapRemove( h, h->idx[0] ); } return retval; } /* Assigns a new key ( and optionally, new data ) to the front element and * re-sorts the heap if necessary. */ 257 int airHeapFrontUpdate( airHeap *h, double newKey, const void *newData ) { if ( h==NULL || h->key_a->len==0 ) return 1; if ( newData!=NULL && h->data_a!=NULL ) memcpy( ( char* )h->data_a->data+h->idx[0]*h->data_a->unit, newData, h->data_a->unit ); h->key[h->idx[0]]=newKey; downheap( h, 0 ); return 0; } /* The following functions provide advanced functionality and should * not be required in most applications. */ /* airHeapFind returns 0 if an element is found whose data is bitwise * equal to the given data, and sets *ai to the index of this * element. If more than one element matches the data, an arbitrary * one of them is returned. The index can be used with airHeapRemove * or airHeapUpdate, but will become invalid as soon as any element is * removed from the heap. */ 277 int airHeapFind( const airHeap *h, unsigned int *ai, const void *data ) { unsigned int i; if ( h==NULL || ai==NULL || data==NULL || h->data_a==NULL ) return 1; for ( i=0; i<h->key_a->len; i++ ) { if ( !memcmp( ( char* )h->data_a->data+i*h->data_a->unit, data, h->data_a->unit ) ) { *ai = i; return 0; } } return 1; } /* Removes element ai from the heap, returns 0 upon success. */ 292 int airHeapRemove( airHeap *h, unsigned int ai ) { unsigned int old_invidx_ai; if ( h==NULL || h->key_a->len<=ai ) return 1; /* in the tree, replace ai with last element */ old_invidx_ai=h->invidx[ai]; h->idx[h->invidx[ai]]=h->idx[h->key_a->len-1]; h->invidx[h->idx[h->key_a->len-1]]=h->invidx[ai]; /* remove ai - copy last element over, then drop it */ if ( ai!=h->key_a->len-1 ) { h->key[ai]=h->key[h->key_a->len-1]; if ( h->data_a!=NULL ) { memcpy( ( char* )h->data_a->data+ai*h->data_a->unit, ( char* )h->data_a->data+( h->key_a->len-1 )*h->data_a->unit, h->data_a->unit ); } h->idx[h->invidx[h->key_a->len-1]]=ai; h->invidx[ai]=h->invidx[h->key_a->len-1]; } heapLenIncr( h, -1 ); /* push moved element downheap */ if ( old_invidx_ai<h->key_a->len ) downheap( h, old_invidx_ai ); return 0; } /* Changes the key ( and optional data ) of the element ai, re-sorting * the heap if necessary. Returns 0 upon success. */ 320 int airHeapUpdate( airHeap *h, unsigned int ai, double newKey, const void *newData ) { double oldkey; if ( h==NULL || h->key_a->len<=ai ) return 1; oldkey = h->key[ai]; /* replace key and data */ h->key[ai] = newKey; if ( h->data_a!=NULL && newData!=NULL ) { memcpy( ( char* )h->data_a->data+ai*h->data_a->unit, newData, h->data_a->unit ); } if ( oldkey<newKey ) downheap( h, h->invidx[ai] ); else upheap( h, h->invidx[ai] ); return 0; }

/Users/scm/git/github/teem/src/air/math.c

/Users/scm/git/github/teem/src/air/miscAir.c

/Users/scm/git/github/teem/src/air/mop.c

/Users/scm/git/github/teem/src/air/parseAir.c

/Users/scm/git/github/teem/src/air/randMT.c

/Users/scm/git/github/teem/src/air/sane.c

/Users/scm/git/github/teem/src/air/string.c

/Users/scm/git/github/teem/src/air/test/bessy.c

/Users/scm/git/github/teem/src/air/test/doubleprint.c

/Users/scm/git/github/teem/src/air/test/floatprint.c

/Users/scm/git/github/teem/src/air/test/fp.c

/Users/scm/git/github/teem/src/air/test/logrice.c

/Users/scm/git/github/teem/src/air/test/tarr.c

/Users/scm/git/github/teem/src/air/test/tdio.c

/Users/scm/git/github/teem/src/air/test/texp.c

/Users/scm/git/github/teem/src/air/test/tline.c

/Users/scm/git/github/teem/src/air/test/tmop.c

/Users/scm/git/github/teem/src/air/test/tok.c

/Users/scm/git/github/teem/src/air/test/tprint.c

/Users/scm/git/github/teem/src/air/test/trand.c

/Users/scm/git/github/teem/src/air/threadAir.c

/Users/scm/git/github/teem/src/alan/coreAlan.c

/Users/scm/git/github/teem/src/alan/enumsAlan.c

/Users/scm/git/github/teem/src/alan/methodsAlan.c

/Users/scm/git/github/teem/src/alan/test/tspot.c

/Users/scm/git/github/teem/src/bane/clip.c

/Users/scm/git/github/teem/src/bane/defaultsBane.c

/Users/scm/git/github/teem/src/bane/gkmsFlotsam.c

/Users/scm/git/github/teem/src/bane/gkmsHvol.c

/Users/scm/git/github/teem/src/bane/gkmsInfo.c

/Users/scm/git/github/teem/src/bane/gkmsMite.c

/Users/scm/git/github/teem/src/bane/gkmsOpac.c

/Users/scm/git/github/teem/src/bane/gkmsPvg.c

/Users/scm/git/github/teem/src/bane/gkmsScat.c

/Users/scm/git/github/teem/src/bane/gkmsTxf.c

/Users/scm/git/github/teem/src/bane/hvol.c

/Users/scm/git/github/teem/src/bane/inc.c

/Users/scm/git/github/teem/src/bane/measr.c

/Users/scm/git/github/teem/src/bane/methodsBane.c

/Users/scm/git/github/teem/src/bane/rangeBane.c

/Users/scm/git/github/teem/src/bane/scat.c

/Users/scm/git/github/teem/src/bane/test/apply.c

/Users/scm/git/github/teem/src/bane/test/htrnsf.c

/Users/scm/git/github/teem/src/bane/test/opac.c

/Users/scm/git/github/teem/src/bane/test/pos.c

/Users/scm/git/github/teem/src/bane/test/pvg.c

/Users/scm/git/github/teem/src/bane/test/sigma.c

/Users/scm/git/github/teem/src/bane/test/tblah.c

/Users/scm/git/github/teem/src/bane/test/tinfo.c

/Users/scm/git/github/teem/src/bane/trex.c

/Users/scm/git/github/teem/src/bane/trnsf.c

/Users/scm/git/github/teem/src/bane/valid.c

/Users/scm/git/github/teem/src/biff/biffbiff.c

/Users/scm/git/github/teem/src/biff/biffmsg.c

/Users/scm/git/github/teem/src/biff/test/test.c

/Users/scm/git/github/teem/src/bin/airSanity.c

/Users/scm/git/github/teem/src/bin/cubic.c

/Users/scm/git/github/teem/src/bin/deconv.c

/Users/scm/git/github/teem/src/bin/emap.c

/Users/scm/git/github/teem/src/bin/gkms.c

/Users/scm/git/github/teem/src/bin/gprobe.c

/Users/scm/git/github/teem/src/bin/ilk.c

/Users/scm/git/github/teem/src/bin/miter.c

/Users/scm/git/github/teem/src/bin/mrender.c

/Users/scm/git/github/teem/src/bin/ninspect.c

/Users/scm/git/github/teem/src/bin/nrrdSanity.c

/Users/scm/git/github/teem/src/bin/overrgb.c

/Users/scm/git/github/teem/src/bin/pprobe.c

/Users/scm/git/github/teem/src/bin/puller.c

/Users/scm/git/github/teem/src/bin/qbert.c

/Users/scm/git/github/teem/src/bin/spots.c

/Users/scm/git/github/teem/src/bin/talkweb.c

/Users/scm/git/github/teem/src/bin/tend.c

/Users/scm/git/github/teem/src/bin/ungantry.c

/Users/scm/git/github/teem/src/bin/unu.c

/Users/scm/git/github/teem/src/bin/vprobe.c

/Users/scm/git/github/teem/src/coil/coreCoil.c

/Users/scm/git/github/teem/src/coil/defaultsCoil.c

/Users/scm/git/github/teem/src/coil/enumsCoil.c

/Users/scm/git/github/teem/src/coil/methodsCoil.c

/Users/scm/git/github/teem/src/coil/realmethods.c

/Users/scm/git/github/teem/src/coil/scalarCoil.c

/Users/scm/git/github/teem/src/coil/tensorCoil.c

/Users/scm/git/github/teem/src/coil/test/coiler.c

/Users/scm/git/github/teem/src/dye/convertDye.c

/Users/scm/git/github/teem/src/dye/methodsDye.c

/Users/scm/git/github/teem/src/dye/test/bow.c

/Users/scm/git/github/teem/src/dye/test/conv.c

/Users/scm/git/github/teem/src/dye/test/iconv.c

/Users/scm/git/github/teem/src/dye/test/mchist.c

/Users/scm/git/github/teem/src/echo/bounds.c

/Users/scm/git/github/teem/src/echo/color.c

/Users/scm/git/github/teem/src/echo/enumsEcho.c

/Users/scm/git/github/teem/src/echo/intx.c

/Users/scm/git/github/teem/src/echo/lightEcho.c

/Users/scm/git/github/teem/src/echo/list.c

/Users/scm/git/github/teem/src/echo/matter.c

/Users/scm/git/github/teem/src/echo/methodsEcho.c

/Users/scm/git/github/teem/src/echo/model.c

/Users/scm/git/github/teem/src/echo/objmethods.c

/Users/scm/git/github/teem/src/echo/renderEcho.c

/Users/scm/git/github/teem/src/echo/set.c

/Users/scm/git/github/teem/src/echo/sqd.c

/Users/scm/git/github/teem/src/echo/test/glyph.c

/Users/scm/git/github/teem/src/echo/test/test.c

/Users/scm/git/github/teem/src/echo/test/trend.c

1 /* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2008, 2007, 2006, 2005 Gordon Kindlmann Copyright ( C ) 2004, 2003, 2002, 2001, 2000, 1999, 1998 University of Utah This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "../echo.h" #include "../privateEcho.h" /* bad bad bad Gordon */ void 28 _dyeHSVtoRGB( float *R, float *G, float *B, float H, float S, float V ) { float min, fract, vsf, mid1, mid2; int sextant; if ( 0 == S ) { *R = *G = *B = V; return; } /* else there is hue */ if ( 1 == H ) H = 0; H *= 6; sextant = ( int ) floor( H ); fract = H - sextant; vsf = V*S*fract; min = V*( 1 - S ); mid1 = min + vsf; mid2 = V - vsf; switch ( sextant ) { case 0: { *R = V; *G = mid1; *B = min; break; } case 1: { *R = mid2; *G = V; *B = min; break; } case 2: { *R = min; *G = V; *B = mid1; break; } case 3: { *R = min; *G = mid2; *B = V; break; } case 4: { *R = mid1; *G = min; *B = V; break; } case 5: { *R = V; *G = min; *B = mid2; break; } } } #if 0 void 60 makeSceneAntialias( limnCamera *cam, echoRTParm *parm, echoObject **sceneP, airArray **lightArrP ) { echoObject *scene, *rect; Nrrd *ntext; *sceneP = scene = echoObjectNew( echoList ); *lightArrP = echoLightArrayNew( ); ELL_3V_SET( cam->from, 0, 0, 10 ); ELL_3V_SET( cam->at, 0, 0, 0 ); ELL_3V_SET( cam->up, 0, 1, 0 ); cam->uRange[0] = -3.7; cam->uRange[1] = 3.7; cam->vRange[0] = -3.7; cam->vRange[1] = 3.7; parm->jitterType = echoJitterGrid; parm->numSamples = 1; parm->imgResU = 300; parm->imgResV = 300; parm->aperture = 0.0; parm->renderLights = AIR_FALSE; parm->renderBoxes = AIR_FALSE; parm->seedRand = AIR_FALSE; parm->maxRecDepth = 10; parm->shadow = 1.0; nrrdLoad( ntext = nrrdNew( ), "chirp.nrrd", NULL ); rect = echoObjectNew( echoRectangle ); echoRectangleSet( rect, -3, -3, 0, 6, 0, 0, 0, 6, 0 ); echoMatterPhongSet( rect, 1, 1, 1, 1.0, 1.0, 0.0, 0.0, 1 ); echoMatterTextureSet( rect, ntext ); echoObjectAdd( scene, rect ); return; } void 102 makeSceneBVH( limnCamera *cam, echoRTParm *parm, echoObject **sceneP ) { echoObject *sphere; int i, N; float r, g, b; echoObject *scene; double time0, time1; *sceneP = scene = echoObjectNew( echoList ); ELL_3V_SET( cam->from, 9, 6, 0 ); ELL_3V_SET( cam->at, 0, 0, 0 ); ELL_3V_SET( cam->up, 0, 0, 1 ); cam->uRange[0] = -3; cam->uRange[1] = 3; cam->vRange[0] = -3; cam->vRange[1] = 3; parm->jitterType = echoJitterNone; parm->numSamples = 1; parm->imgResU = 500; parm->imgResV = 500; parm->aperture = 0.0; parm->renderLights = AIR_TRUE; parm->renderBoxes = AIR_FALSE; parm->seedRand = AIR_FALSE; parm->maxRecDepth = 10; parm->shadow = 0.0; N = 1000000; airArrayLenSet( LIST( scene )->objArr, N ); for ( i=0; i<N; i++ ) { sphere = echoObjectNew( echoSphere ); echoSphereSet( sphere, 4*airDrandMT( )-2, 4*airDrandMT( )-2, 4*airDrandMT( )-2, 0.005 ); _dyeHSVtoRGB( &r, &g, &b, AIR_AFFINE( 0, i, N, 0.0, 1.0 ), 1.0, 1.0 ); echoMatterPhongSet( sphere, r, g, b, 1.0, 1.0, 0.0, 0.0, 50 ); LIST( scene )->obj[i] = sphere; } time0 = airTime( ); *sceneP = scene = echoListSplit3( scene, 8 ); time1 = airTime( ); printf( "BVH build time = %g seconds\n", time1 - time0 ); } void 149 makeSceneGlass( limnCamera *cam, echoRTParm *parm, echoObject **sceneP ) { echoObject *cube, *rect; echoObject *scene; Nrrd *ntext; *sceneP = scene = echoObjectNew( echoList ); ELL_3V_SET( cam->from, 2, -3, 8 ); ELL_3V_SET( cam->at, 0, 0, 0 ); ELL_3V_SET( cam->up, 0, 0, 1 ); cam->uRange[0] = -1.0; cam->uRange[1] = 1.0; cam->vRange[0] = -1.0; cam->vRange[1] = 1.0; parm->jitterType = echoJitterNone; parm->numSamples = 1; parm->imgResU = 300; parm->imgResV = 300; parm->aperture = 0.0; parm->renderLights = AIR_FALSE; parm->shadow = 0.0; parm->seedRand = AIR_FALSE; parm->maxRecDepth = 10; parm->mrR = 1.0; parm->mrG = 0.0; parm->mrB = 1.0; cube = echoObjectNew( echoCube ); printf( "cube = %p\n", cube ); echoMatterGlassSet( cube, 1.0, 1.0, 1.0, 1.5, 0.0, 0.0 ); echoObjectAdd( scene, cube ); nrrdLoad( ntext=nrrdNew( ), "psq.nrrd", NULL ); rect = echoObjectNew( echoRectangle ); printf( "rect = %p\n", rect ); echoRectangleSet( rect, -1, -1, -0.51, 2, 0, 0, 0, 2, 0 ); echoMatterPhongSet( rect, 1.0, 1.0, 1.0, 1.0, 0.1, 0.6, 0.3, 40 ); echoMatterTextureSet( rect, ntext ); echoObjectAdd( scene, rect ); /* light = echoLightNew( echoLightDirectional ); echoLightDirectionalSet( light, 1, 1, 1, 0, 0, 1 ); echoLightArrayAdd( lightArr, light ); */ } void 205 makeSceneGlass2( limnCamera *cam, echoRTParm *parm, echoObject **sceneP ) { echoObject *cube, *rect; echoObject *scene; Nrrd *ntext; echoPos_t matx[16]; *sceneP = scene = echoObjectNew( echoList ); ELL_3V_SET( cam->from, 0, 0, 100 ); ELL_3V_SET( cam->at, 0, 0, 0 ); ELL_3V_SET( cam->up, 0, 1, 0 ); cam->uRange[0] = -1.0; cam->uRange[1] = 1.0; cam->vRange[0] = -1.0; cam->vRange[1] = 1.0; parm->jitterType = echoJitterNone; parm->numSamples = 1; parm->imgResU = 300; parm->imgResV = 300; parm->aperture = 0.0; parm->renderLights = AIR_FALSE; parm->shadow = 0.0; parm->seedRand = AIR_FALSE; parm->maxRecDepth = 10; parm->mrR = 1.0; parm->mrG = 0.0; parm->mrB = 1.0; ELL_4M_SET_SCALE( matx, 0.5, 0.5, 0.5 ); cube = echoRoughSphere( 80, 40, matx ); /* cube = echoObjectNew( echoSphere ); echoSphereSet( cube, 0, 0, 0, 0.5 ); */ echoMatterGlassSet( cube, 1.0, 1.0, 1.0, 1.33333, 0.0, 0.0 ); echoObjectAdd( scene, cube ); nrrdLoad( ntext=nrrdNew( ), "check.nrrd", NULL ); rect = echoObjectNew( echoRectangle ); printf( "rect = %p\n", rect ); echoRectangleSet( rect, -1, -1, -0.51, 2, 0, 0, 0, 2, 0 ); echoMatterPhongSet( rect, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 40 ); echoMatterTextureSet( rect, ntext ); echoObjectAdd( scene, rect ); /* light = echoLightNew( echoLightDirectional ); echoLightDirectionalSet( light, 1, 1, 1, 0, 0, 1 ); echoLightArrayAdd( lightArr, light ); */ } #endif void 268 makeSceneInstance( limnCamera *cam, echoRTParm *parm, echoScene *scene ) { echoObject *trim, *rect, *inst; echoPos_t matx[16], A[16], B[16]; ELL_3V_SET( cam->from, 9*1.3, 9*1.3, 11*1.3 ); ELL_3V_SET( cam->at, 0, 0, 0 ); ELL_3V_SET( cam->up, 0, 0, 1 ); cam->uRange[0] = -5; cam->uRange[1] = 5; cam->vRange[0] = -5; cam->vRange[1] = 5; parm->jitterType = echoJitterNone; parm->numSamples = 1; parm->imgResU = 300; parm->imgResV = 300; parm->aperture = 0.0; parm->renderLights = AIR_TRUE; parm->renderBoxes = AIR_FALSE; parm->seedRand = AIR_FALSE; parm->maxRecDepth = 10; parm->shadow = 1.0; ELL_4M_IDENTITY_SET( matx ); ELL_4M_SCALE_SET( B, 2.5, 1.5, 0.8 ); ELL_4M_MUL( A, B, matx ); ELL_4M_COPY( matx, A ); ELL_4M_ROTATE_X_SET( B, 0.2 ); ELL_4M_MUL( A, B, matx ); ELL_4M_COPY( matx, A ); ELL_4M_ROTATE_Y_SET( B, 0.2 ); ELL_4M_MUL( A, B, matx ); ELL_4M_COPY( matx, A ); ELL_4M_ROTATE_Y_SET( B, 0.2 ); ELL_4M_MUL( A, B, matx ); ELL_4M_COPY( matx, A ); ELL_4M_TRANSLATE_SET( B, 0, 0, 1 ); ELL_4M_MUL( A, B, matx ); ELL_4M_COPY( matx, A ); /* trim = echoRoughSphere( 50, 25, matx ); */ /* trim = echoRoughSphere( 8, 4, matx ); echoMatterGlassSet( trim, 0.8, 0.8, 0.8, 1.3, 0.0, 0.0 ); echoMatterPhongSet( trim, 1, 1, 1, 1.0, 0.1, 0.5, 0.9, 50 ); echoObjectAdd( scene, trim ); */ trim = echoObjectNew( scene, echoTypeSphere ); echoSphereSet( trim, 0, 0, 0, 1 ); echoColorSet( trim, 0.8, 0.8, 0.8, 1.0 ); echoMatterGlassSet( scene, trim, 1.3, 0.0, 0.0, 0.0 ); echoMatterPhongSet( scene, trim, 0.1, 0.5, 0.9, 50 ); inst = echoObjectNew( scene, echoTypeInstance ); echoInstanceSet( inst, matx, trim ); echoObjectAdd( scene, inst ); rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, -3.5, -3.5, -3.5, 7, 0, 0, 0, 7, 0 ); echoColorSet( trim, 1.0, 1.0, 1.0, 1.0 ); echoMatterPhongSet( scene, rect, 0.1, 0.5, 0.9, 50 ); echoObjectAdd( scene, rect ); rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, -3.5, -3.5, -3.5, 0, 7, 0, 0, 0, 7 ); echoColorSet( rect, 1.0, 1.0, 1.0, 1.0 ); echoMatterPhongSet( scene, rect, 0.1, 0.5, 0.9, 50 ); echoObjectAdd( scene, rect ); /* rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, -3.5, -3.5, -3.5, 0, 0, 7, 7, 0, 0 ); */ rect = echoObjectNew( scene, echoTypeSphere ); echoSphereSet( rect, 0, 0, 0, 1 ); echoColorSet( rect, 1.0, 1.0, 1.0, 1.0 ); echoMatterPhongSet( scene, rect, 0.1, 0.5, 0.9, 50 ); inst = echoObjectNew( scene, echoTypeInstance ); ELL_4M_SCALE_SET( A, 20, 20, 20 ); ELL_4M_TRANSLATE_SET( B, 0, -( 20+3.5 ), 0 ); ELL_4M_MUL( matx, B, A ); echoInstanceSet( inst, matx, rect ); echoObjectAdd( scene, inst ); /* light = echoLightNew( echoLightDirectional ); echoLightDirectionalSet( light, 1, 0, 0, 1, 0.001, 0.001 ); echoLightArrayAdd( lightArr, light ); light = echoLightNew( echoLightDirectional ); echoLightDirectionalSet( light, 0, 1, 0, 0.001, 1, 0.001 ); echoLightArrayAdd( lightArr, light ); light = echoLightNew( echoLightDirectional ); echoLightDirectionalSet( light, 0, 0, 1, 0.001, 0.001, 1 ); echoLightArrayAdd( lightArr, light ); */ return; } void 374 makeSceneGlassTest( limnCamera *cam, echoRTParm *parm, echoScene *scene ) { echoObject *cube, *rect, *inst; echoCol_t r=0, g=0, b=0; Nrrd *ntext; int i, N; echoPos_t ma[16], mb[16]; ELL_3V_SET( cam->from, 0, 0, 10 ); ELL_3V_SET( cam->at, 0, 0, 0 ); ELL_3V_SET( cam->up, 1, 0, 0 ); cam->uRange[0] = -1.1; cam->uRange[1] = 1.1; cam->vRange[0] = -1.1; cam->vRange[1] = 1.1; parm->jitterType = echoJitterNone; parm->numSamples = 1; parm->imgResU = 220; parm->imgResV = 220; parm->aperture = 0.0; parm->renderLights = AIR_FALSE; parm->seedRand = AIR_FALSE; ELL_3V_SET( scene->bkgr, 0.2, 0.3, 0.4 ); /* parm->shadow = 0.0; */ /* create scene */ N = 11; for ( i=0; i<N; i++ ) { cube = echoObjectNew( scene, echoTypeCube ); _dyeHSVtoRGB( &r, &g, &b, AIR_AFFINE( 0, i, N, 0.0, 1.0 ), 1.0, 1.0 ); echoColorSet( cube, r, g, b, 1 ); echoMatterGlassSet( scene, cube, 1.1, 0.0, 0.0, 0 ); inst = echoObjectNew( scene, echoTypeInstance ); ELL_4M_IDENTITY_SET( ma ); ELL_4M_SCALE_SET( mb, 1.0/( N+2 ), 0.8, 3.0/( N+2 ) ); ell_4m_POST_MUL( ma, mb ); ELL_4M_ROTATE_X_SET( mb, AIR_AFFINE( 0, i, N-1, -AIR_PI/2, AIR_PI/2 ) ); ell_4m_POST_MUL( ma, mb ); ELL_4M_TRANSLATE_SET( mb, AIR_AFFINE( 0, i, N-1, -0.8, 0.8 ), 0, 1 ); ell_4m_POST_MUL( ma, mb ); echoInstanceSet( inst, ma, cube ); echoObjectAdd( scene, inst ); } rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, -1, 1, 0, 0, -2, 0, 2, 0, 0 ); echoColorSet( rect, 1.0, 1.0, 1.0, 1.0 ); echoMatterPhongSet( scene, rect, 1.0, 0.0, 0.0, 40 ); nrrdLoad( ntext=nrrdNew( ), "pot.png", NULL ); echoMatterTextureSet( scene, rect, ntext ); echoObjectAdd( scene, rect ); rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, -0.25, -0.25, 10, 0.5, 0, 0, 0, 0.5, 0 ); echoColorSet( rect, 1, 1, 1, 1 ); echoMatterLightSet( scene, rect, 1, 0 ); return; } void 441 makeSceneGlassMetal( limnCamera *cam, echoRTParm *parm, echoScene *scene ) { echoObject *sphere, *rect; ELL_3V_SET( cam->from, 4, 0, 5 ); ELL_3V_SET( cam->at, 0, 0, 0 ); ELL_3V_SET( cam->up, -1, 0, 0 ); cam->uRange[0] = -0.7; cam->uRange[1] = 0.7; cam->vRange[0] = -0.0; cam->vRange[1] = 1.4; parm->jitterType = echoJitterJitter; parm->numSamples = 36; parm->imgResU = 220; parm->imgResV = 220; parm->aperture = 0.0; parm->renderLights = AIR_FALSE; parm->seedRand = AIR_FALSE; ELL_3V_SET( scene->bkgr, 0.2, 0.3, 0.4 ); /* create scene */ sphere = echoObjectNew( scene, echoTypeSphere ); echoSphereSet( sphere, 0.70, -0.3, -0.4, 0.1 ); echoColorSet( sphere, 1, 0, 0, 1.0 ); echoMatterPhongSet( scene, sphere, 0.1, 0.6, 0.3, 40 ); echoObjectAdd( scene, sphere ); sphere = echoObjectNew( scene, echoTypeSphere ); echoSphereSet( sphere, 0.66, 0.0, -0.4, 0.1 ); echoColorSet( sphere, 0, 1, 0, 1.0 ); echoMatterGlassSet( scene, sphere, 1.0, 0, 1.0, 0.0 ); echoMatterPhongSet( scene, sphere, 0.1, 0.6, 0.3, 40 ); echoObjectAdd( scene, sphere ); sphere = echoObjectNew( scene, echoTypeSphere ); echoSphereSet( sphere, 0.62, 0.3, -0.4, 0.1 ); echoColorSet( sphere, 0, 0, 1, 1.0 ); echoMatterPhongSet( scene, sphere, 0.1, 0.6, 0.3, 40 ); echoObjectAdd( scene, sphere ); rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, 0.5, 0.5, 0.5, 0, -1, 0, 0, 0, -1 ); echoColorSet( rect, 1.0, 1.0, 1.0, 1.0 ); echoMatterMetalSet( scene, rect, 0.7, 0.0, 0.0, 0.2 ); echoObjectAdd( scene, rect ); rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, -1.5, -1.5, -1, 3, 0, 0, 0, 3, 0 ); echoColorSet( rect, 1.0, 1.0, 1.0, 1.0 ); echoMatterPhongSet( scene, rect, 0.1, 0.6, 0.3, 40 ); echoObjectAdd( scene, rect ); rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, 0.5-0.2, -0.2, 40, 0.4, 0, 0, 0, 0.4, 0 ); echoColorSet( rect, 1, 1, 1, 1 ); echoMatterLightSet( scene, rect, 1, 0 ); return; } void 511 makeSceneTexture( limnCamera *cam, echoRTParm *parm, echoScene *scene ) { echoObject /* *trim, */ *rect, /* *inst, */ *sphere; Nrrd *ntext; ELL_3V_SET( cam->from, 9, 9, 11 ); ELL_3V_SET( cam->at, 0, 0, 0 ); ELL_3V_SET( cam->up, 0, 0, 1 ); cam->uRange[0] = -4; cam->uRange[1] = 4; cam->vRange[0] = -4; cam->vRange[1] = 4; parm->jitterType = echoJitterNone; parm->numSamples = 1; parm->imgResU = 300; parm->imgResV = 300; parm->aperture = 0.0; parm->renderLights = AIR_FALSE; parm->renderBoxes = AIR_FALSE; parm->seedRand = AIR_FALSE; parm->maxRecDepth = 10; parm->shadow = 1.0; rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, -2, -2, 0, 4, 0, 0, 0, 4, 0 ); echoColorSet( rect, 1, 1, 1, 1 ); echoMatterPhongSet( scene, rect, 0.1, 1, 0.9, 50 ); echoObjectAdd( scene, rect ); nrrdLoad( ntext=nrrdNew( ), "tmp.png", NULL ); echoMatterTextureSet( scene, rect, ntext ); sphere = echoObjectNew( scene, echoTypeSphere ); echoSphereSet( sphere, 0, 0, 0, 3 ); echoColorSet( sphere, 1, 1, 1, 1 ); echoMatterPhongSet( scene, sphere, 0.1, 0.5, 0.9, 50 ); echoMatterTextureSet( scene, sphere, ntext ); echoObjectAdd( scene, sphere ); /* ELL_4M_SET_SCALE( matx, 3, 3, 3 ); trim = echoRoughSphere( 80, 40, matx ); echoMatterPhongSet( trim, 1, 1, 1, 1.0, 0.1, 0.5, 0.9, 50 ); echoMatterTextureSet( trim, ntext ); echoObjectAdd( scene, trim ); */ rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, 0, 0, 60, 0, 2, 0, 0, 0, 2 ); echoColorSet( rect, 1, 1, 1, 1 ); echoMatterLightSet( scene, rect, 1, 1 ); return; } void 574 makeSceneDOF( limnCamera *cam, echoRTParm *parm, echoScene *scene ) { echoObject *rect; Nrrd *ntext; ELL_3V_SET( cam->from, 6, 6, 20 ); ELL_3V_SET( cam->at, 0, 0, 0 ); ELL_3V_SET( cam->up, 0, 1, 0 ); cam->uRange[0] = -3.3; cam->uRange[1] = 3.3; cam->vRange[0] = -3.3; cam->vRange[1] = 3.3; parm->jitterType = echoJitterJitter; parm->numSamples = 4; parm->imgResU = 300; parm->imgResV = 300; parm->aperture = 0.5; parm->renderLights = AIR_FALSE; parm->renderBoxes = AIR_FALSE; parm->seedRand = AIR_FALSE; parm->maxRecDepth = 10; parm->shadow = 1.0; nrrdLoad( ntext = nrrdNew( ), "tmp.png", NULL ); rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, -0.5, 1.5, -3, 2, 0, 0, 0, -2, 0 ); echoColorSet( rect, 1, 0.5, 0.5, 1 ); echoMatterPhongSet( scene, rect, 1.0, 0.0, 0.0, 1 ); echoMatterTextureSet( scene, rect, ntext ); echoObjectAdd( scene, rect ); rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, -1, 1, 0, 2, 0, 0, 0, -2, 0 ); echoColorSet( rect, 0.5, 1, 0.5, 1 ); echoMatterPhongSet( scene, rect, 1.0, 0.0, 0.0, 1 ); echoMatterTextureSet( scene, rect, ntext ); echoObjectAdd( scene, rect ); rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, -1.5, 0.5, 3, 2, 0, 0, 0, -2, 0 ); echoColorSet( rect, 0.5, 0.5, 1, 1 ); echoMatterPhongSet( scene, rect, 1.0, 0.0, 0.0, 1 ); echoMatterTextureSet( scene, rect, ntext ); echoObjectAdd( scene, rect ); return; } void 633 makeSceneShadow( limnCamera *cam, echoRTParm *parm, echoScene *scene ) { echoObject *sphere, *rect, *tri; ELL_3V_SET( cam->from, 2, 0, 20 ); ELL_3V_SET( cam->at, 0, 0, 0 ); ELL_3V_SET( cam->up, -1, 0, 0 ); cam->uRange[0] = -1.8; cam->uRange[1] = 1.8; cam->vRange[0] = -1.8; cam->vRange[1] = 1.8; parm->jitterType = echoJitterGrid; parm->numSamples = 9; parm->imgResU = 200; parm->imgResV = 200; parm->aperture = 0.0; parm->renderLights = AIR_FALSE; parm->shadow = 0.5; /* create scene */ sphere = echoObjectNew( scene, echoTypeSphere ); echoSphereSet( sphere, 0, -1, -1, 0.2 ); echoColorSet( sphere, 0.5, 0.5, 1, 1.0 ); echoMatterPhongSet( scene, sphere, 0.1, 0.6, 0.3, 40 ); echoObjectAdd( scene, sphere ); sphere = echoObjectNew( scene, echoTypeSphere ); echoSphereSet( sphere, 0, 1, -1, 0.2 ); echoColorSet( sphere, 1, 0.5, 0.5, 1.0 ); echoMatterPhongSet( scene, sphere, 0.1, 0.6, 0.3, 40 ); echoObjectAdd( scene, sphere ); sphere = echoObjectNew( scene, echoTypeSphere ); echoSphereSet( sphere, 0, 0, 1, 0.2 ); echoColorSet( sphere, 0.5, 1, 0.5, 1.0 ); echoMatterPhongSet( scene, sphere, 0.1, 0.6, 0.3, 40 ); echoObjectAdd( scene, sphere ); tri = echoObjectNew( scene, echoTypeTriangle ); echoTriangleSet( tri, 0, -1, -1, 0, 1, -1, 0, 0, 1 ); echoColorSet( tri, 1, 1, 0, 1.0 ); echoMatterPhongSet( scene, tri, 0.1, 0.6, 0.3, 40 ); echoObjectAdd( scene, tri ); rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, 1.7, 1.7, -2, -3.4, 0, 0, 0, -3.4, 0 ); echoColorSet( rect, 1.0, 0.8, 1.0, 1.0 ); echoMatterPhongSet( scene, rect, 0.1, 0.3, 0.7, 3000 ); echoObjectAdd( scene, rect ); rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, 1.0, 0.2, 4, 0.2, 0, 0, 0, 0.2, 0 ); echoColorSet( rect, 1, 1, 1, 1 ); echoMatterLightSet( scene, rect, 1, 0 ); echoObjectAdd( scene, rect ); } void 700 makeSceneSimple( limnCamera *cam, echoRTParm *parm, echoScene *scene ) { echoObject *tri, *rect, *sphere; Nrrd *ntext; ELL_3V_SET( cam->from, 5, -5, 9 ); ELL_3V_SET( cam->at, 0, 0, 0 ); ELL_3V_SET( cam->up, 0, 0, 1 ); cam->uRange[0] = -3.6; cam->uRange[1] = 3.6; cam->vRange[0] = -3.6; cam->vRange[1] = 3.6; parm->jitterType = echoJitterJitter; parm->numSamples = 9; parm->imgResU = 300; parm->imgResV = 300; parm->aperture = 0.0; parm->textureNN = AIR_FALSE; parm->renderLights = AIR_TRUE; parm->renderBoxes = AIR_FALSE; parm->seedRand = AIR_TRUE; parm->maxRecDepth = 10; ELL_3V_SET( parm->maxRecCol, 0, 0, 0 ); parm->shadow = 1.0; rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, -5, -5, -1.4, 10, 0, 0, 0, 10, 0 ); echoColorSet( rect, 1, 1, 1, 1.0 ); echoMatterPhongSet( scene, rect, 0.1, 0.5, 0.6, 50 ); if ( nrrdLoad( ntext=nrrdNew( ), "pot.png", NULL ) ) { /* oops, no pot */ airFree( biffGetDone( NRRD ) ); nrrdNuke( ntext ); } else { echoMatterTextureSet( scene, rect, ntext ); } echoObjectAdd( scene, rect ); sphere = echoObjectNew( scene, echoTypeSphere ); echoSphereSet( sphere, 0, 0, 0, 1.85 ); echoColorSet( sphere, 1, 1, 1, 1.0 ); echoMatterGlassSet( scene, sphere, 1.5, 0.0, 0.0, 0.0 ); echoMatterMetalSet( scene, sphere, 0.8, 0.0, 1.0, 0.15 ); echoObjectAdd( scene, sphere ); tri = echoObjectNew( scene, echoTypeTriangle ); echoTriangleSet( tri, 0.1, 0.1, 2, 2, 2, 2, 0, 2, 2 ); echoColorSet( tri, 1, 0.4, 0.4, 1.0 ); echoMatterPhongSet( scene, tri, 0.4, 0.6, 0.0, 90 ); echoObjectAdd( scene, tri ); tri = echoObjectNew( scene, echoTypeTriangle ); echoTriangleSet( tri, -0.1, 0.1, 2, -2, 2, 2, -2, 0, 2 ); echoColorSet( tri, 0.4, 1.0, 0.4, 1.0 ); echoMatterPhongSet( scene, tri, 0.4, 0.6, 0.0, 90 ); echoObjectAdd( scene, tri ); tri = echoObjectNew( scene, echoTypeTriangle ); echoTriangleSet( tri, -0.1, -0.1, 2, -2, -2, 2, 0, -2, 2 ); echoColorSet( tri, 0.4, 0.4, 1.0, 1.0 ); echoMatterPhongSet( scene, tri, 0.4, 0.6, 0.0, 90 ); echoObjectAdd( scene, tri ); rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, -0.5, -0.5, 10, 1.0, 0.0, 0, 0.0, 1.0, 0 ); echoColorSet( rect, 1, 1, 1, 1 ); echoMatterLightSet( scene, rect, 1, 0 ); echoObjectAdd( scene, rect ); return; } void 788 makeSceneRainLights( limnCamera *cam, echoRTParm *parm, echoScene *scene ) { echoObject *sphere, *rect; int i, N; echoPos_t w; float r=0, g=0, b=0; ELL_3V_SET( cam->from, 2.5, 0, 5 ); ELL_3V_SET( cam->at, 0, 0, 0 ); ELL_3V_SET( cam->up, 0, 0, 1 ); cam->uRange[0] = -1.7; cam->uRange[1] = 1.7; cam->vRange[0] = -1.7; cam->vRange[1] = 1.7; parm->jitterType = echoJitterJitter; parm->numSamples = 36; parm->imgResU = 1000; parm->imgResV = 1000; parm->numSamples = 16; parm->imgResU = 200; parm->imgResV = 200; parm->aperture = 0.0; parm->renderLights = AIR_TRUE; parm->shadow = 0.0; ELL_3V_SET( scene->bkgr, 0.1, 0.1, 0.1 ); /* create scene */ sphere = echoObjectNew( scene, echoTypeSphere ); echoSphereSet( sphere, 0, 0, 0, 1.0 ); echoColorSet( sphere, 1.0, 1.0, 1.0, 1.0 ); echoMatterPhongSet( scene, sphere, 0.02, 0.2, 1.0, 400 ); echoObjectAdd( scene, sphere ); N = 8; w = 1.7/N; for ( i=0; i<N; i++ ) { rect = echoObjectNew( scene, echoTypeRectangle ); echoRectangleSet( rect, w/2, AIR_AFFINE( 0, i, N-1, -1-w/2, 1-w/2 ), 1.5, 0, w, 0, w, 0, 0 ); _dyeHSVtoRGB( &r, &g, &b, AIR_AFFINE( 0, i, N, 0.0, 1.0 ), 1.0, 1.0 ); echoColorSet( rect, r, g, b, 1 ); echoMatterLightSet( scene, rect, 1, 0 ); echoObjectAdd( scene, rect ); } } int 839 main( int argc, char **argv ) { Nrrd *nraw; limnCamera *cam; echoRTParm *parm; echoGlobalState *state; echoScene *scene; airArray *mop; char *me, *err, *env; int E, tmp; AIR_UNUSED( argc ); me = argv[0]; mop = airMopNew( ); cam = limnCameraNew( ); airMopAdd( mop, cam, ( airMopper )limnCameraNix, airMopAlways ); cam->neer = 0; cam->dist = 0; cam->faar = 0; cam->atRelative = AIR_TRUE; cam->dist = 0; cam->rightHanded = AIR_TRUE; parm = echoRTParmNew( ); airMopAdd( mop, parm, ( airMopper )echoRTParmNix, airMopAlways ); state = echoGlobalStateNew( ); airMopAdd( mop, state, ( airMopper )echoGlobalStateNix, airMopAlways ); scene = echoSceneNew( ); airMopAdd( mop, scene, ( airMopper )echoSceneNix, airMopAlways ); nraw = nrrdNew( ); airMopAdd( mop, nraw, ( airMopper )nrrdNuke, airMopAlways ); /* makeSceneGlass( cam, parm, scene ); */ /* makeSceneGlass2( cam, parm, scene ); */ /* makeSceneGlassMetal( cam, parm, scene ); */ /* makeSceneGlassTest( cam, parm, scene ); */ /* makeSceneBVH( cam, parm, scene ); */ /* makeSceneInstance( cam, parm, scene ); */ /* makeSceneTexture( cam, parm, scene ); */ /* makeSceneSimple( cam, parm, scene ); */ /* makeSceneRainLights( cam, parm, scene ); */ /* makeSceneAntialias( cam, parm, scene ); */ makeSceneShadow( cam, parm, scene ); /* makeSceneDOF( cam, parm, scene ); */ if ( ( env = getenv( "NT" ) ) ) { if ( 1 == sscanf( env, "%d", &tmp ) ) { parm->numThreads = tmp; } } else { parm->numThreads = 1; } E = 0; if ( !E ) E |= echoRTRender( nraw, cam, scene, parm, state ); if ( E ) { airMopAdd( mop, err = biffGetDone( ECHO ), airFree, airMopAlways ); fprintf( stderr, "%s: trouble:\n%s\n", me, err ); airMopError( mop ); return 1; } printf( "render time = %g seconds ( %g fps )\n", state->time, 1.0/state->time ); if ( !E ) E |= nrrdSave( "raw.nrrd", nraw, NULL ); if ( E ) { airMopAdd( mop, err = biffGetDone( NRRD ), airFree, airMopAlways ); fprintf( stderr, "%s: trouble:\n%s\n", me, err ); airMopError( mop ); return 1; } airMopOkay( mop ); return 0; }

/Users/scm/git/github/teem/src/elf/ESHEstimElf.c

/* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2013, 2012, 2011, 2010, 2009, 2008 Thomas Schultz This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "elf.h" /* Routines for estimating even-order spherical harmonics or tensor * coefficients. */ /* elfCart2Thetaphi: * * Helper function to transform ct 3D Cartesian coordinates into * theta ( polar angle from positive z ) and phi ( azimuth from positive x ) * Input vectors should be non-zero, but do not need to be normalized * thetaphi needs to be pre-allocated to length 2*ct */ #define ELFCART2THETAPHI( TYPE, SUF ) \ 36 void elfCart2Thetaphi_##SUF( TYPE *thetaphi, const TYPE *dirs, \ unsigned int ct ) { \ unsigned int i; \ for ( i=0; i<ct; i++ ) { \ TYPE r=AIR_CAST( TYPE, ELL_3V_LEN( dirs+3*i ) ); \ TYPE z=dirs[3*i+2]/r; \ if ( z>1 ) thetaphi[2*i]=0; \ else if ( z<-1 ) thetaphi[2*i]=AIR_CAST( TYPE, AIR_PI ); \ else thetaphi[2*i]=AIR_CAST( TYPE, acos( z ) ); \ thetaphi[2*i+1]=AIR_CAST( TYPE, atan2( dirs[3*i+1], dirs[3*i] ) ); \ } \ } \ ELFCART2THETAPHI( double, d ) ELFCART2THETAPHI( float, f ) /* elfESHEstimMatrix: * * Computes a matrix T that can be used to transform a measurement vector v * of ct values on the sphere, at positions given by thetaphi, into a vector * c of ESH coefficients of the desired order ( c=Tv ) such that the ESH * series approximates the given values in a least squares sense. 58 * 59 * T needs to be pre-allocated to length len( c )*ct * If H is non-NULL, it should be pre-allocated to length ct*ct * In this case, the "hat" matrix will be written to H, which maps the * measurement vector v to the corresponding model predictions * If lambda>0, Laplace-Beltrami regularization is employed * If w is non-NULL, it is assumed to be a weight vector with len( w )=ct * * Returns 0 on success * 1 if order is unsupported * 2 if len( v )<len( c ) ( i.e., system is underdetermined ) */ #define ELFESHESTIMMATRIX( TYPE, SUF ) \ int elfESHEstimMatrix_##SUF( TYPE *T, TYPE *H, unsigned int order, \ const TYPE *thetaphi, \ unsigned int ct, TYPE lambda, TYPE *w ) { \ double *B, *M, *Minv; \ unsigned int N, i, j, k; \ Nrrd *nmat, *ninv; \ if ( order>tijk_max_esh_order || order%2!=0 ) \ return 1; \ N=tijk_esh_len[order/2]; \ if ( ct<N ) return 2; \ \ /* intermediate computations are always done in double precision */ \ B = ( double* ) malloc( sizeof( double )*N*ct ); \ M = ( double* ) malloc( sizeof( double )*N*N ); \ \ /* build the transformation matrix */ \ /* B has row major format -> all SHs that belong to the same \ * thetaphi are stored sequentially */ \ for ( i=0; i<ct; i++ ) { \ tijk_eval_esh_basis_d( B+N*i, order, thetaphi[2*i], thetaphi[2*i+1] ); \ } \ if ( w!=NULL ) { /* weighted fit */ \ for ( i=0; i<N; ++i ) /* row index */ \ for ( j=0; j<N; ++j ) { /* column index */ \ M[N*i+j]=0.0; \ for ( k=0; k<ct; ++k ) { \ M[N*i+j]+=B[N*k+i]*B[N*k+j]*w[k]; \ } \ } \ } else { /* unweighted fit */ \ for ( i=0; i<N; ++i ) /* row index */ \ for ( j=0; j<N; ++j ) { /* column index */ \ M[N*i+j]=0.0; \ for ( k=0; k<ct; ++k ) { \ M[N*i+j]+=B[N*k+i]*B[N*k+j]; \ } \ } \ } \ /* if desired, perform Laplace-Beltrami regularization */ \ if ( lambda>0 ) { \ unsigned int idx=0, o; \ for ( o=0; o<=order; o+=2 ) { /* order */ \ while ( idx<tijk_esh_len[o/2] ) { \ M[N*idx+idx]+=lambda*o*o*( o+1 )*( o+1 ); \ idx++; \ } \ } \ } \ /* invert what we have up to now */ \ nmat = nrrdNew( ); \ ninv = nrrdNew( ); \ nmat->dim=2; \ nmat->type=nrrdTypeDouble; \ nmat->axis[0].size=nmat->axis[1].size=N; \ nmat->data=M; \ ell_Nm_inv( ninv, nmat ); \ Minv = ( double* ) ninv->data; \ \ /* create final transformation matrix */ \ if ( w!=NULL ) { /* weighted */ \ for ( i=0; i<N; ++i ) /* row index */ \ for ( j=0; j<ct; ++j ) { \ unsigned int idx=ct*i+j; \ T[idx]=0.0; \ for ( k=0; k<N; ++k ) { \ T[idx]+=AIR_CAST( TYPE, Minv[N*i+k]*B[N*j+k]*w[j] ); \ } \ } \ } else { /* unweighted */ \ for ( i=0; i<N; ++i ) /* row index */ \ for ( j=0; j<ct; ++j ) { \ unsigned int idx=ct*i+j; \ T[idx]=0.0; \ for ( k=0; k<N; ++k ) { \ T[idx]+=AIR_CAST( TYPE, Minv[N*i+k]*B[N*j+k] ); \ } \ } \ } \ nmat = nrrdNix( nmat ); \ ninv = nrrdNuke( ninv ); \ \ if ( H!=NULL ) { /* H = BT */ \ for ( i=0; i<ct; i++ ) /* row index */ \ for ( j=0; j<ct; j++ ) { \ unsigned int idx=ct*i+j; \ H[idx]=0.0; \ for ( k=0; k<N; k++ ) { /* sum over all SH coeffs */ \ H[idx]+=AIR_CAST( TYPE, B[N*i+k]*T[k*ct+j] ); \ } \ } \ } \ \ free( M ); \ free( B ); \ return 0; \ } ELFESHESTIMMATRIX( double, d ) ELFESHESTIMMATRIX( float, f ) /* elfTenEstimMatrix: * * Computes a matrix T that can be used to transform a measurement vector v * of ct values, associated with vectors at vecs, into a vector * t of symmetric tensor coefficients of the given type ( t=Tv ) such that the * tensor approximates the given values in a least squares sense. * * T needs to be pre-allocated to length len( c )*ct * If H is non-NULL, it should be pre-allocated to length ct*ct * In this case, the "hat" matrix will be written to H, which maps the * measurement vector v to the corresponding model predictions * If w is non-NULL, it is assumed to be a weight vector with len( w )=ct * * Returns 0 on success * 1 if tensor type is unsupported * 2 if len( v )<len( c ) ( i.e., system is underdetermined ) */ /* This is strongly modeled on elfESHEstimMatrix */ #define ELFTENESTIMMATRIX( TYPE, SUF ) \ int elfTenEstimMatrix_##SUF( TYPE *T, TYPE *H, const tijk_type *type, \ const TYPE *vecs, \ unsigned int ct, TYPE *w ) { \ double *B, *M, *Minv; \ unsigned int N, i, j, k; \ Nrrd *nmat, *ninv; \ if ( type==NULL || type->sym==NULL || ( type->dim!=2 && type->dim!=3 ) ) \ return 1; \ N=type->num; \ if ( ct<N ) return 2; \ \ /* intermediate computations are always done in double precision */ \ B = ( double* ) malloc( sizeof( double )*N*ct ); \ M = ( double* ) malloc( sizeof( double )*N*N ); \ \ /* build the transformation matrix */ \ /* B has row major format -> all coeffs that belong to the same \ * vec are stored sequentially */ \ for ( i=0; i<ct; i++ ) { \ double vec[3]; \ if ( type->dim==2 ) { \ ELL_2V_COPY( vec, vecs+2*i ); \ } else { \ ELL_3V_COPY( vec, vecs+3*i ); \ } \ ( *type->sym->make_rank1_d )( B+N*i, 1.0, vec ); \ } \ for ( j=0; j<N; j++ ) { \ /* at this point, take sqrt of multiplicities to make \ * condition number for inversion rotation invariant */ \ double factor=sqrt( type->mult[j] ); \ for ( i=0; i<ct; i++ ) \ B[N*i+j]*=factor; \ } \ if ( w!=NULL ) { /* weighted fit */ \ for ( i=0; i<N; ++i ) /* row index */ \ for ( j=0; j<N; ++j ) { /* column index */ \ M[N*i+j]=0.0; \ for ( k=0; k<ct; ++k ) { \ M[N*i+j]+=B[N*k+i]*B[N*k+j]*w[k]; \ } \ } \ } else { /* unweighted fit */ \ for ( i=0; i<N; ++i ) /* row index */ \ for ( j=0; j<N; ++j ) { /* column index */ \ M[N*i+j]=0.0; \ for ( k=0; k<ct; ++k ) { \ M[N*i+j]+=B[N*k+i]*B[N*k+j]; \ } \ } \ } \ /* invert what we have up to now */ \ nmat = nrrdNew( ); \ ninv = nrrdNew( ); \ nmat->dim=2; \ nmat->type=nrrdTypeDouble; \ nmat->axis[0].size=nmat->axis[1].size=N; \ nmat->data=M; \ ell_Nm_inv( ninv, nmat ); \ Minv = ( double* ) ninv->data; \ \ /* create final transformation matrix */ \ if ( w!=NULL ) { /* weighted */ \ for ( i=0; i<N; ++i ) /* row index */ \ for ( j=0; j<ct; ++j ) { \ unsigned int idx=ct*i+j; \ T[idx]=0.0; \ for ( k=0; k<N; ++k ) { \ T[idx]+=AIR_CAST( TYPE, Minv[N*i+k]*B[N*j+k]*w[j] ); \ } \ } \ } else { /* unweighted */ \ for ( i=0; i<N; ++i ) /* row index */ \ for ( j=0; j<ct; ++j ) { \ unsigned int idx=ct*i+j; \ T[idx]=0.0; \ for ( k=0; k<N; ++k ) { \ T[idx]+=AIR_CAST( TYPE, Minv[N*i+k]*B[N*j+k] ); \ } \ } \ } \ nmat = nrrdNix( nmat ); \ ninv = nrrdNuke( ninv ); \ \ if ( H!=NULL ) { /* H = BT */ \ for ( i=0; i<ct; i++ ) /* row index */ \ for ( j=0; j<ct; j++ ) { \ unsigned int idx=ct*i+j; \ H[idx]=0.0; \ for ( k=0; k<N; k++ ) { /* sum over all tensor coeffs */ \ H[idx]+=AIR_CAST( TYPE, B[N*i+k]*T[k*ct+j] ); \ } \ } \ } \ \ /* divide sqrt( multiplicities ) out of T to comply with tijk's \ * ( non-premultiplied ) representation of tensors */ \ for ( i=0; i<N; i++ ) { \ double factor=1.0/sqrt( type->mult[i] ); \ for ( j=0; j<ct; j++ ) \ T[ct*i+j]*=factor; \ } \ \ free( M ); \ free( B ); \ return 0; \ } ELFTENESTIMMATRIX( double, d ) ELFTENESTIMMATRIX( float, f )

/Users/scm/git/github/teem/src/elf/ballStickElf.c

/Users/scm/git/github/teem/src/elf/glyphElf.c

1 /* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2010, 2009 Thomas Schultz This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "elf.h" const int elfPresent = 42; /* Glyphs for higher-order tensors */ /* Helper routine to estimate normals in a triangle soup in which antipodal * vertices are subsequent */ static void 32 estimateNormalsAntipodal ( limnPolyData *glyph, const char normalize ) { unsigned int faceno=glyph->indxNum/3; unsigned int *faces=glyph->indx; unsigned int f; memset( glyph->norm, 0, sizeof( float )*3*glyph->xyzwNum ); for ( f=0; f<faceno/2; f++ ) { float diff1[3], diff2[3], cross[3]; ELL_3V_SUB( diff1, glyph->xyzw+4*faces[3*f+1], glyph->xyzw+4*faces[3*f] ); ELL_3V_SUB( diff2, glyph->xyzw+4*faces[3*f+2], glyph->xyzw+4*faces[3*f] ); ELL_3V_CROSS( cross, diff1, diff2 ); ELL_3V_INCR( glyph->norm+3*faces[3*f], cross ); ELL_3V_INCR( glyph->norm+3*faces[3*f+1], cross ); ELL_3V_INCR( glyph->norm+3*faces[3*f+2], cross ); /* same for anti-face */ if ( faces[3*f]%2==0 ) ELL_3V_SUB( glyph->norm+3*faces[3*f]+3, glyph->norm+3*faces[3*f]+3, cross ); else ELL_3V_SUB( glyph->norm+3*faces[3*f]-3, glyph->norm+3*faces[3*f]-3, cross ); if ( faces[3*f+1]%2==0 ) ELL_3V_SUB( glyph->norm+3*faces[3*f+1]+3, glyph->norm+3*faces[3*f+1]+3, cross ); else ELL_3V_SUB( glyph->norm+3*faces[3*f+1]-3, glyph->norm+3*faces[3*f+1]-3, cross ); if ( faces[3*f+2]%2==0 ) ELL_3V_SUB( glyph->norm+3*faces[3*f+2]+3, glyph->norm+3*faces[3*f+2]+3, cross ); else ELL_3V_SUB( glyph->norm+3*faces[3*f+2]-3, glyph->norm+3*faces[3*f+2]-3, cross ); } if ( normalize ) { float len; unsigned int i; for ( i=0; i<glyph->normNum; i++ ) { ELL_3V_NORM_TT( glyph->norm + 3*i, float, glyph->norm + 3*i, len ); } } } /* ******** elfGlyphPolar ** ** Turns a unit sphere into a polar plot that depicts a given tensor. ** ** Input: ** glyph is expected to represent the unit sphere ** antipodal can be set to a non-zero value if antipodal points on the sphere ** are subsequent in the input. It will lead to faster processing. ** ( this can be used together with limnPolyDataIcoSphere ) ** ten is an input tensor of type type ** clamp - if nonzero, negative values will be clamped to zero ** normalize - if nonzero, surface normals will be rescaled to unit length ** posColor[4] - RGBA color code for positive values ( if desired, else NULL ) ** negColor[4] - RGBA color code for negative values ( if desired, else NULL ) ** ** Output: ** glyph is the polar plot that corresponds to ten. ** If the input shape was anything other than a unit sphere, the output ** shape is undefined ** Normals are only updated when they were allocated in the input ** When colors were present in the input, they are replaced by a color ** coding of sign ( if pos/negColor!=NULL ) or a pointwise XYZ-RGB map ( else ) ** When isdef!=NULL, *isdef is set to 0 if we found evidence that the given ** input tensor is not positive definite ** The return value is the radius of the glyph's bounding sphere */ float 104 elfGlyphPolar( limnPolyData *glyph, const char antipodal, const float *ten, const tijk_type *type, char *isdef, const char clamp, const char normalize, const unsigned char *posColor, const unsigned char *negColor ) { float *verts=glyph->xyzw; float max=0; unsigned int i, infoBitFlag; char def=1; infoBitFlag = limnPolyDataInfoBitFlag( glyph ); for ( i=0; i<glyph->xyzwNum; i++ ) { float val=( *type->sym->s_form_f )( ten, verts ); /* if RGBA is allocated, take care of coloring */ if ( infoBitFlag & ( 1 << limnPolyDataInfoRGBA ) ) { /* color by sign */ if ( val<0 && negColor!=NULL ) { ELL_4V_COPY( glyph->rgba+4*i, negColor ); if ( antipodal ) ELL_4V_COPY( glyph->rgba+4*i+4, negColor ); } else if ( val>0 && posColor!=NULL ) { ELL_4V_COPY( glyph->rgba+4*i, posColor ); if ( antipodal ) ELL_4V_COPY( glyph->rgba+4*i+4, posColor ); } else { /* RGB encode the vertex coordinates */ ELL_4V_SET_TT( glyph->rgba+4*i, unsigned char, 255*fabs( verts[0] ), 255*fabs( verts[1] ), 255*fabs( verts[2] ), 255 ); if ( antipodal ) { ELL_4V_COPY( glyph->rgba+4*i+4, glyph->rgba+4*i ); } } } if ( val<0 ) { def=0; if ( clamp ) val=0; else val=-val; } if ( val>max ) max=val; ELL_3V_SCALE( verts, val, verts ); if ( antipodal ) { ELL_3V_SCALE( verts+4, -1.0f, verts ); verts+=4; i++; } verts+=4; } if ( isdef!=NULL ) *isdef=def; if ( infoBitFlag & ( 1 << limnPolyDataInfoNorm ) ) { /* take care of normals */ if ( antipodal && glyph->primNum==1 && glyph->type[0]==limnPrimitiveTriangles ) { /* we can use our specialized, more efficient code */ estimateNormalsAntipodal( glyph, normalize ); } else { /* use standard limn routine */ limnPolyDataVertexNormals( glyph ); } } return max; } /* ******** elfGlyphHOME ** ** Turns a unit sphere into a HOME glyph that depicts a given tensor. ** ** Input: ** glyph is expected to represent the unit sphere ** antipodal can be set to a non-zero value if antipodal points on the sphere ** are subsequent in the input. It will lead to faster processing. ** ( this can be used together with limnPolyDataIcoSphere ) ** ten is an input tensor of type type ** normalize - if nonzero, normals will be rescaled to unit length ** ** Output: ** glyph is the HOME glyph that corresponds to ten. ** If the input shape was anything other than a unit sphere, the output ** shape is undefined ** If the input tensor does not have a rank-k decomposition with positive ** coefficients, the output shape may self-intersect ** Normals are only updated when they were allocated in the input ** When colors were present in the input, they are replaced by a ** pointwise XYZ-RGB map ** When isdef!=NULL, *isdef is set to 0 if we found evidence that the given ** input tensor is not positive definite ** The return value is the radius of the glyph's bounding sphere, or -1 ** upon error ( odd tensor order; HOME glyph is only defined for even orders ) */ float 193 elfGlyphHOME( limnPolyData *glyph, const char antipodal, const float *ten, const tijk_type *type, char *isdef, const char normalize ) { float *verts=glyph->xyzw; float max=0; unsigned int i, infoBitFlag; char def=1; if ( type->order%2==1 ) /* sanity check */ return -1; infoBitFlag = limnPolyDataInfoBitFlag( glyph ); for ( i=0; i<glyph->xyzwNum; i++ ) { float HOMEpos[3], len; ( *type->sym->v_form_f )( HOMEpos, ten, verts ); if ( ELL_3V_DOT( HOMEpos, verts )<0 ) def=0; ELL_3V_COPY( verts, HOMEpos ); len=AIR_CAST( float, ELL_3V_LEN( HOMEpos ) ); if ( len>max ) max=len; /* if RGBA is allocated, take care of coloring */ if ( infoBitFlag & ( 1 << limnPolyDataInfoRGBA ) ) { float c[3]; if ( len>1e-18 ) ELL_3V_SET_TT( c, float, fabs( verts[0]/len ), fabs( verts[1]/len ), fabs( verts[2]/len ) ); else ELL_3V_SET( c, 0, 0, 0 ); /* RGB encode the vertex coordinates */ ELL_4V_SET_TT( glyph->rgba+4*i, unsigned char, 255*c[0], 255*c[1], 255*c[2], 255 ); if ( antipodal ) { ELL_4V_COPY( glyph->rgba+4*i+4, glyph->rgba+4*i ); } } if ( antipodal ) { ELL_3V_SCALE( verts+4, -1.0f, verts ); verts+=4; i++; } verts+=4; } if ( isdef!=NULL ) *isdef=def; if ( infoBitFlag & ( 1 << limnPolyDataInfoNorm ) ) { /* take care of normals */ if ( antipodal && glyph->primNum==1 && glyph->type[0]==limnPrimitiveTriangles ) { /* we can use our specialized faster code */ estimateNormalsAntipodal( glyph, normalize ); } else { /* use standard limn routine */ limnPolyDataVertexNormals( glyph ); } } return max; } /* ******** elfGlyphKDE ** ** Turns a unit sphere into a polar plot that depicts Kernel Density ** Estimate ( KDE ) of input vectors ** ** Input: ** glyph is expected to represent the unit sphere ** antipodal can be set to a non-zero value if antipodal points on the sphere ** are subsequent in the input, and gamma is even. It will lead to ** faster processing. ** ( this can be used together with limnPolyDataIcoSphere ) ** vecs is a set of n_vecs 3D input vectors ( PDF samples ) ** KDE uses dp kernel with exponent gamma ** normalize - if nonzero, surface normals will be rescaled to unit length ** ** Output: ** glyph is the polar plot that corresponds to KDE of vecs. ** If the input shape was anything other than a unit sphere, the output ** shape is undefined ** ** NOTE ON NORMALIZATION: ** Normalization is such that the maximum radius of the glyph ( when all ** samples agree ) is one. To instead normalize the KDE such that it ** integrates to unity, multiply by ( 2*gamma+1 )/( 4*pi ) ** ** Normals are only updated when they were allocated in the input ** When colors were present in the input, they are replaced by a pointwise ** XYZ-RGB map ** The return value is the radius of the glyph's bounding sphere */ float 280 elfGlyphKDE( limnPolyData *glyph, const char antipodal, const float *vecs, const size_t n_vecs, const float _gamma, const char normalize ) { float *verts=glyph->xyzw; float max=0; unsigned int i, j, infoBitFlag; infoBitFlag = limnPolyDataInfoBitFlag( glyph ); for ( i=0; i<glyph->xyzwNum; i++ ) { /* compute value by looping over all vecs */ double val=0; for ( j=0; j<n_vecs; j++ ) { double dp = ELL_3V_DOT( verts, vecs+3*j ); val+=pow( dp, _gamma ); } val/=n_vecs; /* if RGBA is allocated, take care of coloring */ if ( infoBitFlag & ( 1 << limnPolyDataInfoRGBA ) ) { /* RGB encode the vertex coordinates */ ELL_4V_SET_TT( glyph->rgba+4*i, unsigned char, 255*fabs( verts[0] ), 255*fabs( verts[1] ), 255*fabs( verts[2] ), 255 ); if ( antipodal ) { ELL_4V_COPY( glyph->rgba+4*i+4, glyph->rgba+4*i ); } } if ( val>max ) max=AIR_CAST( float, val ); ELL_3V_SCALE_TT( verts, float, val, verts ); if ( antipodal ) { ELL_3V_SCALE( verts+4, -1.0f, verts ); verts+=4; i++; } verts+=4; } if ( infoBitFlag & ( 1 << limnPolyDataInfoNorm ) ) { /* take care of normals */ if ( antipodal && glyph->primNum==1 && glyph->type[0]==limnPrimitiveTriangles ) { /* we can use our specialized, more efficient code */ estimateNormalsAntipodal( glyph, normalize ); } else { /* use standard limn routine */ limnPolyDataVertexNormals( glyph ); } } return max; } /* ******** elfColorGlyphMaxima ** ** Maximum-based coloring of tensor glyphs, as described in Section 4 of ** Schultz/Kindlmann, EuroVis 2010 ** ** Input: ** glyph is a tensor glyph ( generated by elfGlyph* ) ** antipodal can be set to a non-zero value if antipodal points on the sphere ** are subsequent in the input. It will lead to faster processing. ** neighbors is an array that, for each vertex in glyph, holds the indices ** of its neighbors ( adjacent through an edge ). Each vertex has ** nbstride entries, padded with -1s if it really has less neighbors ** ten is the tensor depicted by the glyph ** type is the tensor type ** modulate - non-zero values lead to modulation by peak sharpness ** gamma - allows you to "bump up" the peak sharpness by the power of gamma ** ** Output: ** glyph is colored according to its maxima ** returns zero upon success ( fails if memory cannot be allocated ) */ int 352 elfColorGlyphMaxima( limnPolyData *glyph, const char antipodal, const int *neighbors, unsigned int nbstride, const float *ten, const tijk_type *type, const char modulate, const float _gamma ) { float *sqrdist, *verts, *newcol; char *processed, *id_ct, *diff_ct; int *path; unsigned int infoBitFlag, i, j; airArray *mop; infoBitFlag = limnPolyDataInfoBitFlag( glyph ); if ( limnPolyDataAlloc( glyph, /* make sure we have a color buffer */ infoBitFlag | ( 1 << limnPolyDataInfoRGBA ), glyph->xyzwNum, glyph->indxNum, glyph->primNum ) ) { return 1; } /* do the memory allocation */ mop = airMopNew( ); if ( mop==NULL ) return 1; sqrdist = ( float * ) malloc( sizeof( float )*glyph->xyzwNum ); airMopAdd( mop, sqrdist, airFree, airMopAlways ); processed = ( char * ) malloc( sizeof( char )*glyph->xyzwNum ); airMopAdd( mop, processed, airFree, airMopAlways ); path = ( int * ) malloc( sizeof( int )*glyph->xyzwNum ); airMopAdd( mop, path, airFree, airMopAlways ); newcol = ( float * ) malloc( sizeof( float )*3*glyph->xyzwNum ); airMopAdd( mop, newcol, airFree, airMopAlways ); id_ct = ( char * ) malloc( sizeof( char )*glyph->xyzwNum ); airMopAdd( mop, id_ct, airFree, airMopAlways ); diff_ct = ( char * ) malloc( sizeof( char )*glyph->xyzwNum ); airMopAdd( mop, diff_ct, airFree, airMopAlways ); if ( sqrdist==NULL || processed==NULL || path==NULL || newcol==NULL || id_ct==NULL || diff_ct==NULL ) { airMopError( mop ); return 1; } /* initialize sqrdist / processed / path */ verts=glyph->xyzw; if ( antipodal ) { for ( i=0; i<glyph->xyzwNum; i+=2 ) { sqrdist[i]=sqrdist[i+1]=ELL_3V_DOT( verts, verts ); verts+=8; } } else { for ( i=0; i<glyph->xyzwNum; i++ ) { sqrdist[i]=ELL_3V_DOT( verts, verts ); verts+=4; } } memset( processed, 0, sizeof( char )*glyph->xyzwNum ); memset( path, -1, sizeof( int )*glyph->xyzwNum ); /* go through all vertices; ascend until we get to a maximum or a * previously processed vertex */ for ( i=0; i<glyph->xyzwNum; i++ ) { unsigned int pathno=0; int vert=i; char foundmax=0; unsigned char color[3]; if ( processed[i] ) continue; path[pathno++]=vert; while ( !foundmax ) { int bestnb=-1; float maxdist=0; for ( j=0; j<nbstride; ++j ) { int nb=neighbors[nbstride*vert+j]; float dist; if ( nb==-1 ) break; dist=sqrdist[nb]-sqrdist[vert]; if ( dist>maxdist ) { maxdist=dist; bestnb=nb; } } if ( bestnb==-1 ) { /* we are at an unprocessed maximum */ /* find appropriate color */ float vertdir[3]; float norm; float modfactor=1.0; ELL_3V_COPY( vertdir, glyph->xyzw+4*vert ); norm=AIR_CAST( float, ELL_3V_LEN( vertdir ) ); if ( norm>1e-18 ) { ELL_3V_SCALE( vertdir, 1.0f/norm, vertdir ); if ( modulate ) { /* modulate by peak strength */ float hess[7], val, evals[3]; /* compute second derivatives */ ( *type->sym->hess_f )( hess+1, ten, vertdir ); val=( *type->sym->s_form_f )( ten, vertdir ); tenEigensolve_f( evals, NULL, hess ); if ( evals[1]>=0 || val<1e-10 ) { modfactor=0.0; } else { modfactor=-evals[1]/( type->order*val ); if ( modfactor>1.0 ) modfactor=1.0; else modfactor=AIR_CAST( float, pow( modfactor, _gamma ) ); } } } else { ELL_3V_SET( vertdir, 0, 0, 0 ); } ELL_3V_SET( color, ( unsigned char ) ( AIR_LERP( modfactor, 1.0, fabs( vertdir[0] ) )*255 ), ( unsigned char ) ( AIR_LERP( modfactor, 1.0, fabs( vertdir[1] ) )*255 ), ( unsigned char ) ( AIR_LERP( modfactor, 1.0, fabs( vertdir[2] ) )*255 ) ); foundmax=1; } else { if ( processed[bestnb] ) { ELL_3V_COPY( color, glyph->rgba+4*bestnb ); foundmax=1; } else { /* add bestnb to the path and proceed */ path[pathno++]=bestnb; vert=bestnb; } } } /* end looking for maximum */ /* copy color to all vertices on the path */ for ( j=0; j<pathno; ++j ) { processed[path[j]]=1; ELL_4V_SET( glyph->rgba+4*path[j], color[0], color[1], color[2], 255 ); if ( antipodal ) { int antip=path[j]+1; if ( antip%2==0 ) antip-=2; processed[antip]=1; ELL_4V_COPY( glyph->rgba+4*antip, glyph->rgba+4*path[j] ); } } if ( antipodal ) i++; /* we can skip over the next one */ } /* make coloring smoother by averaging */ memset( newcol, 0, sizeof( float )*3*glyph->xyzwNum ); memset( id_ct, 0, sizeof( char )*glyph->xyzwNum ); memset( diff_ct, 0, sizeof( char )*glyph->xyzwNum ); for ( i=0; i<glyph->xyzwNum; i++ ) { for ( j=0; j<nbstride; j++ ) { int nb=neighbors[nbstride*i+j]; if ( nb<0 ) break; if ( ( unsigned int )nb<i ) continue; /* process each pair only once */ if ( ELL_3V_EQUAL( glyph->rgba+4*i, glyph->rgba+4*nb ) ) { id_ct[i]++; id_ct[nb]++; } else { ELL_3V_INCR( newcol+3*i, glyph->rgba+4*nb ); diff_ct[i]++; ELL_3V_INCR( newcol+3*nb, glyph->rgba+4*i ); diff_ct[nb]++; } } } for ( i=0; i<glyph->xyzwNum; i++ ) { if ( diff_ct[i]>0 ) { ELL_3V_SCALE_INCR_TT( newcol+3*i, float, 1.0+id_ct[i], glyph->rgba+4*i ); ELL_3V_SCALE_TT( glyph->rgba+4*i, unsigned char, 1.0/( 1.0+id_ct[i]+diff_ct[i] ), newcol+3*i ); if ( antipodal ) { ELL_3V_COPY( glyph->rgba+4*i+4, glyph->rgba+4*i ); i++; } } } airMopOkay( mop ); return 0; }

/Users/scm/git/github/teem/src/elf/maximaElf.c

1 /* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2011, 2010, 2009 Thomas Schultz This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "elf.h" /* Creates an elfMaximaContext, which can then be used to find all * maxima of a symmetric even-order 3D tensor of the given type. * Returns NULL if type is not even-order 3D symmetric. * * The initial maximum sampling is at the vertices of a subdivided * icosahedron - level=3 ( 321 unique directions ) should be * sufficient. Larger levels reduce the risk of missing one of two ( or * more ) very close maxima, at increased computational cost. */ 32 elfMaximaContext *elfMaximaContextNew( const tijk_type *type, unsigned int level ) { elfMaximaContext *retval; limnPolyData *sphere; unsigned int vert; if ( type==NULL || type->dim!=3 || type->sym==NULL || type->order%2!=0 ) return NULL; /* elfMaxima cannot be used with this tensor type */ sphere = limnPolyDataNew( ); limnPolyDataIcoSphere( sphere, 0, level ); retval = ( elfMaximaContext* ) malloc( sizeof( elfMaximaContext ) ); retval->num = sphere->xyzwNum; retval->type = type; retval->parm = NULL; retval->refine = 1; /* extract neighborhood info ( needed to take discrete maxima ) */ limnPolyDataNeighborArray( &( retval->neighbors ), &( retval->nbstride ), sphere ); /* copy over vertices in single and double precision */ retval->vertices_f = ( float* ) malloc( sizeof( float )*3*( sphere->xyzwNum/2 ) ); for ( vert=0; vert<sphere->xyzwNum; vert+=2 ) { ELL_3V_COPY( retval->vertices_f+3*( vert/2 ), sphere->xyzw+4*vert ); } retval->vertices_d = NULL; sphere=limnPolyDataNix( sphere ); return retval; } 58 elfMaximaContext *elfMaximaContextNix( elfMaximaContext *emc ) { if ( emc!=NULL ) { free( emc->neighbors ); free( emc->vertices_f ); if ( emc->vertices_d!=NULL ) free( emc->vertices_d ); if ( emc->parm!=NULL ) tijk_refine_rank1_parm_nix( emc->parm ); free( emc ); } return NULL; } /* can be used to set the parameters for refining the found local * maxima. Note that the elfMaximaContext will "take over possession" * of the parm struct, i.e., it will be nix'ed along with the context * or when setting another parm */ 75 void elfMaximaParmSet( elfMaximaContext *emc, tijk_refine_rank1_parm *parm ) { if ( emc!=NULL ) { if ( emc->parm!=NULL ) tijk_refine_rank1_parm_nix( emc->parm ); emc->parm=parm; } } /* By default, discrete maxima are refined via optimization on the sphere. * Set this to zero for faster, but less accurate results. */ 86 void elfMaximaRefineSet( elfMaximaContext *emc, int refine ) { if ( emc!=NULL ) { emc->refine = refine; } } /* Finds discrete maxima of the tensor ( based on emc ) and refines them, * storing magnitudes in ( malloc'ed ) *ls and *vs. Returns the number of * distinct maxima, or -1 on error. ls are sorted in descending order. */ 96 int elfMaximaFind_d( double **ls, double **vs, const double *ten, elfMaximaContext *emc ) { unsigned int i; int retval; double *vals; airHeap *heap; if ( ls==NULL || vs==NULL || ten==NULL || emc==NULL ) return -1; if ( emc->vertices_d==NULL ) { /* we need to allocate these */ emc->vertices_d = ( double* ) malloc( sizeof( double )*3*( emc->num/2 ) ); for ( i=0; i<emc->num/2; i++ ) { ELL_3V_COPY( emc->vertices_d+3*i, emc->vertices_f+3*i ); } } /* evaluate all unique directions */ vals = ( double* ) malloc( sizeof( double )*( emc->num/2 ) ); for ( i=0; i<emc->num/2; i++ ) { vals[i]=( *emc->type->sym->s_form_d )( ten, emc->vertices_d+3*i ); } heap = airHeapNew( sizeof( double )*3, 20 ); /* identify discrete maxima */ for ( i=0; i<emc->num/2; i++ ) { unsigned int ni=0; int ismax=1, nb; while ( ni<emc->nbstride && ( nb=emc->neighbors[emc->nbstride*2*i+ni] )!=-1 ) { if ( vals[i]<=vals[nb/2] ) { ismax=0; break; } ni++; } if ( ismax ) { double s=vals[i], v[3]; ELL_3V_COPY( v, emc->vertices_d+3*i ); if ( emc->refine ) /* refine further */ tijk_refine_max_3d_d( &s, v, ten, emc->type, emc->parm ); /* add to heap */ airHeapInsert( heap, -s, v ); } } /* allocate arrays and return what we have found */ retval=airHeapLength( heap ); if ( retval>0 ) { *ls = ( double* ) malloc( sizeof( double )*retval ); *vs = ( double* ) malloc( sizeof( double )*3*retval ); for ( i=0; i<( unsigned int )retval; i++ ) { ( *ls )[i]=-airHeapFrontPop( heap, ( *vs )+3*i ); } } heap=airHeapNix( heap ); free( vals ); return retval; } /* Mostly copy-pasted from above :-/ */ 152 int elfMaximaFind_f( float **ls, float **vs, const float *ten, elfMaximaContext *emc ) { unsigned int i; int retval; float *vals; airHeap *heap; if ( ls==NULL || vs==NULL || ten==NULL || emc==NULL ) return -1; /* evaluate all unique directions */ vals = ( float* ) malloc( sizeof( float )*( emc->num/2 ) ); for ( i=0; i<emc->num/2; i++ ) { vals[i]=( *emc->type->sym->s_form_f )( ten, emc->vertices_f+3*i ); } heap = airHeapNew( sizeof( float )*3, 20 ); /* identify discrete maxima */ for ( i=0; i<emc->num/2; i++ ) { unsigned int ni=0; int ismax=1, nb; while ( ni<emc->nbstride && ( nb=emc->neighbors[emc->nbstride*2*i+ni] )!=-1 ) { if ( vals[i]<=vals[nb/2] ) { ismax=0; break; } ni++; } if ( ismax ) { float s=vals[i], v[3]; ELL_3V_COPY( v, emc->vertices_f+3*i ); if ( emc->refine ) /* refine further */ tijk_refine_max_3d_f( &s, v, ten, emc->type, emc->parm ); /* add to heap */ airHeapInsert( heap, -s, v ); } } /* allocate arrays and return what we have found */ retval=airHeapLength( heap ); if ( retval>0 ) { *ls = ( float* ) malloc( sizeof( float )*retval ); *vs = ( float* ) malloc( sizeof( float )*3*retval ); for ( i=0; i<( unsigned int )retval; i++ ) { ( *ls )[i]=AIR_CAST( float, -airHeapFrontPop( heap, ( *vs )+3*i ) ); } } heap=airHeapNix( heap ); free( vals ); return retval; }

/Users/scm/git/github/teem/src/ell/cubicEll.c

/Users/scm/git/github/teem/src/ell/eigen.c

/Users/scm/git/github/teem/src/ell/genmat.c

/Users/scm/git/github/teem/src/ell/mat.c

/Users/scm/git/github/teem/src/ell/miscEll.c

/Users/scm/git/github/teem/src/ell/quat.c

/Users/scm/git/github/teem/src/ell/test/es6.c

/Users/scm/git/github/teem/src/ell/test/inter.c

/Users/scm/git/github/teem/src/ell/test/invert.c

/Users/scm/git/github/teem/src/ell/test/mmul.c

/Users/scm/git/github/teem/src/ell/test/rot2aa.c

/Users/scm/git/github/teem/src/ell/test/sort3.c

/Users/scm/git/github/teem/src/ell/test/tq.c

/Users/scm/git/github/teem/src/ell/test/wheel.c

/Users/scm/git/github/teem/src/ell/vecEll.c

/Users/scm/git/github/teem/src/gage/ctx.c

/Users/scm/git/github/teem/src/gage/deconvolve.c

/Users/scm/git/github/teem/src/gage/defaultsGage.c

/Users/scm/git/github/teem/src/gage/filter.c

/Users/scm/git/github/teem/src/gage/kind.c

/Users/scm/git/github/teem/src/gage/miscGage.c

/Users/scm/git/github/teem/src/gage/multiGage.c

/Users/scm/git/github/teem/src/gage/optimsig.c

/Users/scm/git/github/teem/src/gage/print.c

/Users/scm/git/github/teem/src/gage/pvl.c

/Users/scm/git/github/teem/src/gage/scl.c

/Users/scm/git/github/teem/src/gage/sclanswer.c

/Users/scm/git/github/teem/src/gage/sclfilter.c

/Users/scm/git/github/teem/src/gage/sclprint.c

/Users/scm/git/github/teem/src/gage/shape.c

/Users/scm/git/github/teem/src/gage/st.c

/Users/scm/git/github/teem/src/gage/stack.c

/Users/scm/git/github/teem/src/gage/stackBlur.c

/Users/scm/git/github/teem/src/gage/test/aalias.c

/Users/scm/git/github/teem/src/gage/test/ctfix.c

/Users/scm/git/github/teem/src/gage/test/demo.c

/Users/scm/git/github/teem/src/gage/test/genoptsig.c

/Users/scm/git/github/teem/src/gage/test/indx.c

/Users/scm/git/github/teem/src/gage/test/maxes.c

/Users/scm/git/github/teem/src/gage/test/ssc.c

1 /* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2013, 2012, 2011, 2010, 2009, 2008 University of Chicago Copyright ( C ) 2008, 2007, 2006, 2005 Gordon Kindlmann Copyright ( C ) 2004, 2003, 2002, 2001, 2000, 1999, 1998 University of Utah This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "../gage.h" char *Info = ( "for doing silly conversions" ); int 29 main( int argc, const char *argv[] ) { const char *me; hestOpt *hopt; hestParm *hparm; airArray *mop; double val; me = argv[0]; mop = airMopNew( ); hparm = hestParmNew( ); hopt = NULL; airMopAdd( mop, hparm, ( airMopper )hestParmFree, airMopAlways ); hestOptAdd( &hopt, NULL, "val", airTypeDouble, 1, 1, &val, NULL, "input value" ); hestParseOrDie( hopt, argc-1, argv+1, hparm, me, Info, AIR_TRUE, AIR_TRUE, AIR_TRUE ); airMopAdd( mop, hopt, ( airMopper )hestOptFree, airMopAlways ); airMopAdd( mop, hopt, ( airMopper )hestParseFree, airMopAlways ); printf( "%s: tee % 10.7g -> sig % 10.7g tau % 10.7g\n", me, val, gageSigOfTau( gageTauOfTee( val ) ), gageTauOfTee( val ) ); printf( "%s: tau % 10.7g -> sig % 10.7g tee % 10.7g\n", me, val, gageSigOfTau( val ), gageTeeOfTau( val ) ); printf( "%s: sig % 10.7g -> tee % 10.7g tau % 10.7g\n", me, val, gageTeeOfTau( gageTauOfSig( val ) ), gageTauOfSig( val ) ); airMopOkay( mop ); exit( 0 ); }

/Users/scm/git/github/teem/src/gage/test/tplot.c

/Users/scm/git/github/teem/src/gage/test/vh.c

/Users/scm/git/github/teem/src/gage/twovecGage.c

/Users/scm/git/github/teem/src/gage/update.c

/Users/scm/git/github/teem/src/gage/vecGage.c

/Users/scm/git/github/teem/src/gage/vecprint.c

/Users/scm/git/github/teem/src/hest/defaultsHest.c

/Users/scm/git/github/teem/src/hest/methodsHest.c

/Users/scm/git/github/teem/src/hest/parseHest.c

/Users/scm/git/github/teem/src/hest/test/bday.c

/Users/scm/git/github/teem/src/hest/test/ex0.c

/Users/scm/git/github/teem/src/hest/test/ex1.c

/Users/scm/git/github/teem/src/hest/test/ex2.c

/Users/scm/git/github/teem/src/hest/test/ex3.c

/Users/scm/git/github/teem/src/hest/test/ex4.c

/Users/scm/git/github/teem/src/hest/test/ex5.c

/Users/scm/git/github/teem/src/hest/test/strings.c

/Users/scm/git/github/teem/src/hest/test/tmpl.c

/Users/scm/git/github/teem/src/hest/usage.c

/Users/scm/git/github/teem/src/hex/dehex.c

/Users/scm/git/github/teem/src/hex/enhex.c

/Users/scm/git/github/teem/src/hoover/defaultsHoover.c

/Users/scm/git/github/teem/src/hoover/methodsHoover.c

/Users/scm/git/github/teem/src/hoover/rays.c

/Users/scm/git/github/teem/src/hoover/stub.c

/Users/scm/git/github/teem/src/limn/cam.c

/Users/scm/git/github/teem/src/limn/defaultsLimn.c

/Users/scm/git/github/teem/src/limn/enumsLimn.c

/Users/scm/git/github/teem/src/limn/envmap.c

/Users/scm/git/github/teem/src/limn/hestLimn.c

/Users/scm/git/github/teem/src/limn/io.c

/Users/scm/git/github/teem/src/limn/light.c

/Users/scm/git/github/teem/src/limn/lpuFlotsam.c

/Users/scm/git/github/teem/src/limn/lpu_about.c

/Users/scm/git/github/teem/src/limn/lpu_ccfind.c

/Users/scm/git/github/teem/src/limn/lpu_meas.c

/Users/scm/git/github/teem/src/limn/lpu_psel.c

/Users/scm/git/github/teem/src/limn/lpu_rast.c

/Users/scm/git/github/teem/src/limn/lpu_sort.c

/Users/scm/git/github/teem/src/limn/lpu_verts.c

/Users/scm/git/github/teem/src/limn/methodsLimn.c

/Users/scm/git/github/teem/src/limn/obj.c

/Users/scm/git/github/teem/src/limn/polydata.c

/Users/scm/git/github/teem/src/limn/polyfilter.c

/Users/scm/git/github/teem/src/limn/polymod.c

/Users/scm/git/github/teem/src/limn/polyshapes.c

1 /* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2013, 2012, 2011, 2010, 2009 University of Chicago Copyright ( C ) 2010, 2009, 2008 Thomas Schultz Copyright ( C ) 2008, 2007, 2006, 2005 Gordon Kindlmann Copyright ( C ) 2004, 2003, 2002, 2001, 2000, 1999, 1998 University of Utah This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "limn.h" int 29 limnPolyDataCube( limnPolyData *pld, unsigned int infoBitFlag, int sharpEdge ) { static const char me[]="limnPolyDataCube"; unsigned int vertNum, vertIdx, primNum, indxNum, cnum, ci; vertNum = sharpEdge ? 6*4 : 8; primNum = 1; indxNum = 6*4; if ( limnPolyDataAlloc( pld, infoBitFlag, vertNum, indxNum, primNum ) ) { biffAddf( LIMN, "%s: couldn't allocate output", me ); return 1; } pld->type[0] = limnPrimitiveQuads; pld->icnt[0] = indxNum; vertIdx = 0; cnum = sharpEdge ? 3 : 1; for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, -1, -1, -1, 1 ); vertIdx++; } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, -1, 1, -1, 1 ); vertIdx++; } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, 1, 1, -1, 1 ); vertIdx++; } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, 1, -1, -1, 1 ); vertIdx++; } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, -1, -1, 1, 1 ); vertIdx++; } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, -1, 1, 1, 1 ); vertIdx++; } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, 1, 1, 1, 1 ); vertIdx++; } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, 1, -1, 1, 1 ); vertIdx++; } vertIdx = 0; if ( sharpEdge ) { ELL_4V_SET( pld->indx + vertIdx, 0, 3, 6, 9 ); vertIdx += 4; ELL_4V_SET( pld->indx + vertIdx, 2, 14, 16, 5 ); vertIdx += 4; ELL_4V_SET( pld->indx + vertIdx, 4, 17, 18, 8 ); vertIdx += 4; ELL_4V_SET( pld->indx + vertIdx, 7, 19, 21, 10 ); vertIdx += 4; ELL_4V_SET( pld->indx + vertIdx, 1, 11, 23, 13 ); vertIdx += 4; ELL_4V_SET( pld->indx + vertIdx, 12, 22, 20, 15 ); vertIdx += 4; } else { ELL_4V_SET( pld->indx + vertIdx, 0, 1, 2, 3 ); vertIdx += 4; ELL_4V_SET( pld->indx + vertIdx, 0, 4, 5, 1 ); vertIdx += 4; ELL_4V_SET( pld->indx + vertIdx, 1, 5, 6, 2 ); vertIdx += 4; ELL_4V_SET( pld->indx + vertIdx, 2, 6, 7, 3 ); vertIdx += 4; ELL_4V_SET( pld->indx + vertIdx, 0, 3, 7, 4 ); vertIdx += 4; ELL_4V_SET( pld->indx + vertIdx, 4, 7, 6, 5 ); vertIdx += 4; } if ( ( 1 << limnPolyDataInfoNorm ) & infoBitFlag ) { if ( sharpEdge ) { ELL_3V_SET( pld->norm + 3*0, 0, 0, -1 ); ELL_3V_SET( pld->norm + 3*3, 0, 0, -1 ); ELL_3V_SET( pld->norm + 3*6, 0, 0, -1 ); ELL_3V_SET( pld->norm + 3*9, 0, 0, -1 ); ELL_3V_SET( pld->norm + 3*2, -1, 0, 0 ); ELL_3V_SET( pld->norm + 3*5, -1, 0, 0 ); ELL_3V_SET( pld->norm + 3*14, -1, 0, 0 ); ELL_3V_SET( pld->norm + 3*16, -1, 0, 0 ); ELL_3V_SET( pld->norm + 3*4, 0, 1, 0 ); ELL_3V_SET( pld->norm + 3*8, 0, 1, 0 ); ELL_3V_SET( pld->norm + 3*17, 0, 1, 0 ); ELL_3V_SET( pld->norm + 3*18, 0, 1, 0 ); ELL_3V_SET( pld->norm + 3*7, 1, 0, 0 ); ELL_3V_SET( pld->norm + 3*10, 1, 0, 0 ); ELL_3V_SET( pld->norm + 3*19, 1, 0, 0 ); ELL_3V_SET( pld->norm + 3*21, 1, 0, 0 ); ELL_3V_SET( pld->norm + 3*1, 0, -1, 0 ); ELL_3V_SET( pld->norm + 3*11, 0, -1, 0 ); ELL_3V_SET( pld->norm + 3*13, 0, -1, 0 ); ELL_3V_SET( pld->norm + 3*23, 0, -1, 0 ); ELL_3V_SET( pld->norm + 3*12, 0, 0, 1 ); ELL_3V_SET( pld->norm + 3*15, 0, 0, 1 ); ELL_3V_SET( pld->norm + 3*20, 0, 0, 1 ); ELL_3V_SET( pld->norm + 3*22, 0, 0, 1 ); } else { float cn; cn = AIR_CAST( float, sqrt( 3.0 ) ); ELL_3V_SET( pld->norm + 3*0, -cn, -cn, -cn ); ELL_3V_SET( pld->norm + 3*1, -cn, cn, -cn ); ELL_3V_SET( pld->norm + 3*2, cn, cn, -cn ); ELL_3V_SET( pld->norm + 3*3, cn, -cn, -cn ); ELL_3V_SET( pld->norm + 3*4, -cn, -cn, cn ); ELL_3V_SET( pld->norm + 3*5, -cn, cn, cn ); ELL_3V_SET( pld->norm + 3*6, cn, cn, cn ); ELL_3V_SET( pld->norm + 3*7, cn, -cn, cn ); } } if ( ( 1 << limnPolyDataInfoRGBA ) & infoBitFlag ) { for ( vertIdx=0; vertIdx<pld->rgbaNum; vertIdx++ ) { ELL_4V_SET( pld->rgba + 4*vertIdx, 255, 255, 255, 255 ); } } return 0; } int 139 limnPolyDataCubeTriangles( limnPolyData *pld, unsigned int infoBitFlag, int sharpEdge ) { static const char me[]="limnPolyDataCubeTriangles"; unsigned int vertNum, vertIdx, primNum, indxNum, cnum, ci; vertNum = sharpEdge ? 6*4 : 8; primNum = 1; indxNum = 6*6; if ( limnPolyDataAlloc( pld, infoBitFlag, vertNum, indxNum, primNum ) ) { biffAddf( LIMN, "%s: couldn't allocate output", me ); return 1; } pld->type[0] = limnPrimitiveTriangles; pld->icnt[0] = indxNum; vertIdx = 0; cnum = sharpEdge ? 3 : 1; for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, 1, -1, 1, 1 ); vertIdx++; } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, -1, -1, 1, 1 ); vertIdx++; } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, 1, 1, 1, 1 ); vertIdx++; } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, -1, 1, 1, 1 ); vertIdx++; } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, 1, 1, -1, 1 ); vertIdx++; } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, -1, 1, -1, 1 ); vertIdx++; } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, 1, -1, -1, 1 ); vertIdx++; } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, -1, -1, -1, 1 ); vertIdx++; } vertIdx = 0; if ( sharpEdge ) { ELL_3V_SET( pld->indx + vertIdx, 0, 6, 3 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 3, 6, 9 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 7, 12, 10 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 10, 12, 16 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 11, 15, 4 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 4, 15, 21 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 17, 14, 22 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 22, 14, 20 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 2, 5, 19 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 19, 5, 23 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 13, 8, 18 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 18, 8, 1 ); vertIdx += 3; } else { ELL_3V_SET( pld->indx + vertIdx, 0, 2, 1 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 1, 2, 3 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 2, 4, 3 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 3, 4, 5 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 3, 5, 1 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 1, 5, 7 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 5, 4, 7 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 7, 4, 6 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 7, 6, 1 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 1, 6, 0 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 4, 2, 6 ); vertIdx += 3; ELL_3V_SET( pld->indx + vertIdx, 2, 6, 0 ); vertIdx += 3; } if ( ( 1 << limnPolyDataInfoNorm ) & infoBitFlag ) { if ( sharpEdge ) { ELL_3V_SET( pld->norm + 3*14, 0, 0, -1 ); ELL_3V_SET( pld->norm + 3*17, 0, 0, -1 ); ELL_3V_SET( pld->norm + 3*20, 0, 0, -1 ); ELL_3V_SET( pld->norm + 3*22, 0, 0, -1 ); ELL_3V_SET( pld->norm + 3* 4, -1, 0, 0 ); ELL_3V_SET( pld->norm + 3*11, -1, 0, 0 ); ELL_3V_SET( pld->norm + 3*15, -1, 0, 0 ); ELL_3V_SET( pld->norm + 3*21, -1, 0, 0 ); ELL_3V_SET( pld->norm + 3* 7, 0, 1, 0 ); ELL_3V_SET( pld->norm + 3*10, 0, 1, 0 ); ELL_3V_SET( pld->norm + 3*12, 0, 1, 0 ); ELL_3V_SET( pld->norm + 3*16, 0, 1, 0 ); ELL_3V_SET( pld->norm + 3* 1, 1, 0, 0 ); ELL_3V_SET( pld->norm + 3* 8, 1, 0, 0 ); ELL_3V_SET( pld->norm + 3*13, 1, 0, 0 ); ELL_3V_SET( pld->norm + 3*18, 1, 0, 0 ); ELL_3V_SET( pld->norm + 3* 2, 0, -1, 0 ); ELL_3V_SET( pld->norm + 3* 5, 0, -1, 0 ); ELL_3V_SET( pld->norm + 3*19, 0, -1, 0 ); ELL_3V_SET( pld->norm + 3*23, 0, -1, 0 ); ELL_3V_SET( pld->norm + 3* 0, 0, 0, 1 ); ELL_3V_SET( pld->norm + 3* 3, 0, 0, 1 ); ELL_3V_SET( pld->norm + 3* 6, 0, 0, 1 ); ELL_3V_SET( pld->norm + 3* 9, 0, 0, 1 ); } else { float cn; cn = AIR_CAST( float, 1.0/sqrt( 3.0 ) ); ELL_3V_SET( pld->norm + 3*0, cn, -cn, cn ); ELL_3V_SET( pld->norm + 3*1, -cn, -cn, cn ); ELL_3V_SET( pld->norm + 3*2, cn, cn, cn ); ELL_3V_SET( pld->norm + 3*3, -cn, cn, cn ); ELL_3V_SET( pld->norm + 3*4, cn, cn, -cn ); ELL_3V_SET( pld->norm + 3*5, -cn, cn, -cn ); ELL_3V_SET( pld->norm + 3*6, cn, -cn, -cn ); ELL_3V_SET( pld->norm + 3*7, -cn, -cn, -cn ); } } if ( ( 1 << limnPolyDataInfoTex2 ) & infoBitFlag ) { if ( sharpEdge ) { ELL_2V_SET( pld->tex2 + 2*14, 1, 1 ); ELL_2V_SET( pld->tex2 + 2*17, 0, 1 ); ELL_2V_SET( pld->tex2 + 2*20, 1, 0 ); ELL_2V_SET( pld->tex2 + 2*22, 0, 0 ); ELL_2V_SET( pld->tex2 + 2* 4, 1, 0 ); ELL_2V_SET( pld->tex2 + 2*11, 0, 0 ); ELL_2V_SET( pld->tex2 + 2*15, 0, 1 ); ELL_2V_SET( pld->tex2 + 2*21, 1, 1 ); ELL_2V_SET( pld->tex2 + 2* 7, 0, 0 ); ELL_2V_SET( pld->tex2 + 2*10, 1, 0 ); ELL_2V_SET( pld->tex2 + 2*12, 0, 1 ); ELL_2V_SET( pld->tex2 + 2*16, 1, 1 ); ELL_2V_SET( pld->tex2 + 2* 1, 0, 0 ); ELL_2V_SET( pld->tex2 + 2* 8, 1, 0 ); ELL_2V_SET( pld->tex2 + 2*13, 1, 1 ); ELL_2V_SET( pld->tex2 + 2*18, 0, 1 ); ELL_2V_SET( pld->tex2 + 2* 2, 1, 0 ); ELL_2V_SET( pld->tex2 + 2* 5, 0, 0 ); ELL_2V_SET( pld->tex2 + 2*19, 1, 1 ); ELL_2V_SET( pld->tex2 + 2*23, 0, 1 ); ELL_2V_SET( pld->tex2 + 2* 0, 1, 1 ); ELL_2V_SET( pld->tex2 + 2* 3, 0, 1 ); ELL_2V_SET( pld->tex2 + 2* 6, 1, 0 ); ELL_2V_SET( pld->tex2 + 2* 9, 0, 0 ); } else { ELL_2V_SET( pld->tex2 + 2*0, 1, 1 ); ELL_2V_SET( pld->tex2 + 2*1, 0, 1 ); ELL_2V_SET( pld->tex2 + 2*2, 1, 0 ); ELL_2V_SET( pld->tex2 + 2*3, 0, 0 ); ELL_2V_SET( pld->tex2 + 2*4, 1, 0 ); ELL_2V_SET( pld->tex2 + 2*5, 0, 0 ); ELL_2V_SET( pld->tex2 + 2*6, 1, 1 ); ELL_2V_SET( pld->tex2 + 2*7, 0, 1 ); } } if ( ( 1 << limnPolyDataInfoTang ) & infoBitFlag ) { if ( sharpEdge ) { ELL_3V_SET( pld->tang + 3*14, 1, 0, 0 ); ELL_3V_SET( pld->tang + 3*17, 1, 0, 0 ); ELL_3V_SET( pld->tang + 3*20, 1, 0, 0 ); ELL_3V_SET( pld->tang + 3*22, 1, 0, 0 ); ELL_3V_SET( pld->tang + 3* 4, 0, -1, 0 ); ELL_3V_SET( pld->tang + 3*11, 0, -1, 0 ); ELL_3V_SET( pld->tang + 3*15, 0, -1, 0 ); ELL_3V_SET( pld->tang + 3*21, 0, -1, 0 ); ELL_3V_SET( pld->tang + 3* 7, -1, 0, 0 ); ELL_3V_SET( pld->tang + 3*10, -1, 0, 0 ); ELL_3V_SET( pld->tang + 3*12, -1, 0, 0 ); ELL_3V_SET( pld->tang + 3*16, -1, 0, 0 ); ELL_3V_SET( pld->tang + 3* 1, 0, 1, 0 ); ELL_3V_SET( pld->tang + 3* 8, 0, 1, 0 ); ELL_3V_SET( pld->tang + 3*13, 0, 1, 0 ); ELL_3V_SET( pld->tang + 3*18, 0, 1, 0 ); ELL_3V_SET( pld->tang + 3* 2, 1, 0, 0 ); ELL_3V_SET( pld->tang + 3* 5, 1, 0, 0 ); ELL_3V_SET( pld->tang + 3*19, 1, 0, 0 ); ELL_3V_SET( pld->tang + 3*23, 1, 0, 0 ); ELL_3V_SET( pld->tang + 3* 0, 1, 0, 0 ); ELL_3V_SET( pld->tang + 3* 3, 1, 0, 0 ); ELL_3V_SET( pld->tang + 3* 6, 1, 0, 0 ); ELL_3V_SET( pld->tang + 3* 9, 1, 0, 0 ); } else { float sn; sn = AIR_CAST( float, 1.0/sqrt( 2.0 ) ); ELL_3V_SET( pld->tang + 3*0, -sn, sn, 0 ); ELL_3V_SET( pld->tang + 3*1, sn, sn, 0 ); ELL_3V_SET( pld->tang + 3*2, -sn, -sn, 0 ); ELL_3V_SET( pld->tang + 3*3, sn, -sn, 0 ); ELL_3V_SET( pld->tang + 3*4, -sn, -sn, 0 ); ELL_3V_SET( pld->tang + 3*5, sn, -sn, 0 ); ELL_3V_SET( pld->tang + 3*6, -sn, sn, 0 ); ELL_3V_SET( pld->tang + 3*7, sn, sn, 0 ); } } if ( ( 1 << limnPolyDataInfoRGBA ) & infoBitFlag ) { for ( vertIdx=0; vertIdx<pld->rgbaNum; vertIdx++ ) { ELL_4V_SET( pld->rgba + 4*vertIdx, 255, 255, 255, 255 ); } } return 0; } int 349 limnPolyDataOctahedron( limnPolyData *pld, unsigned int infoBitFlag, int sharpEdge ) { static const char me[]="limnPolyDataOctahedron"; unsigned int vertNum, vertIdx, primNum, indxNum, cnum, ci; vertNum = sharpEdge ? 4*6 : 6; primNum = 1; indxNum = 8*3; if ( limnPolyDataAlloc( pld, infoBitFlag, vertNum, indxNum, primNum ) ) { biffAddf( LIMN, "%s: couldn't allocate output", me ); return 1; } pld->type[0] = limnPrimitiveTriangles; pld->icnt[0] = indxNum; vertIdx = 0; cnum = sharpEdge ? 4 : 1; for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, 0, 0, 1, 1 ); vertIdx++; /* 0 */ } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, 0, 1, 0, 1 ); vertIdx++; /* 1 */ } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, 1, 0, 0, 1 ); vertIdx++; /* 2 */ } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, 0, -1, 0, 1 ); vertIdx++; /* 3 */ } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, -1, 0, 0, 1 ); vertIdx++; /* 4 */ } for ( ci=0; ci<cnum; ci++ ) { ELL_4V_SET( pld->xyzw + 4*vertIdx, 0, 0, -1, 1 ); vertIdx++; /* 5 */ } vertIdx = 0; if ( sharpEdge ) { ELL_3V_SET( pld->indx + vertIdx, 0, 8, 4 ); vertIdx += 3; /* 0 */ ELL_3V_SET( pld->indx + vertIdx, 1, 15, 9 ); vertIdx += 3; /* 1 */ ELL_3V_SET( pld->indx + vertIdx, 2, 16, 12 ); vertIdx += 3; /* 2 */ ELL_3V_SET( pld->indx + vertIdx, 3, 6, 19 ); vertIdx += 3; /* 3 */ ELL_3V_SET( pld->indx + vertIdx, 5, 11, 23 ); vertIdx += 3; /* 4 */ ELL_3V_SET( pld->indx + vertIdx, 10, 14, 20 ); vertIdx += 3; /* 5 */ ELL_3V_SET( pld->indx + vertIdx, 17, 21, 13 ); vertIdx += 3; /* 6 */ ELL_3V_SET( pld->indx + vertIdx, 7, 22, 18 ); vertIdx += 3; /* 7 */ } else { ELL_3V_SET( pld->indx + vertIdx, 0, 2, 1 ); vertIdx += 3; /* 0 */ ELL_3V_SET( pld->indx + vertIdx, 0, 3, 2 ); vertIdx += 3; /* 1 */ ELL_3V_SET( pld->indx + vertIdx, 0, 4, 3 ); vertIdx += 3; /* 2 */ ELL_3V_SET( pld->indx + vertIdx, 0, 1, 4 ); vertIdx += 3; /* 3 */ ELL_3V_SET( pld->indx + vertIdx, 1, 2, 5 ); vertIdx += 3; /* 4 */ ELL_3V_SET( pld->indx + vertIdx, 2, 3, 5 ); vertIdx += 3; /* 5 */ ELL_3V_SET( pld->indx + vertIdx, 4, 5, 3 ); vertIdx += 3; /* 6 */ ELL_3V_SET( pld->indx + vertIdx, 1, 5, 4 ); vertIdx += 3; /* 7 */ } if ( ( 1 << limnPolyDataInfoNorm ) & infoBitFlag ) { if ( sharpEdge ) { float cn; cn = AIR_CAST( float, 1.0/sqrt( 3 ) ); /* 0 */ ELL_3V_SET( pld->norm + 3*0, cn, cn, cn ); ELL_3V_SET( pld->norm + 3*8, cn, cn, cn ); ELL_3V_SET( pld->norm + 3*4, cn, cn, cn ); /* 1 */ ELL_3V_SET( pld->norm + 3*1, cn, -cn, cn ); ELL_3V_SET( pld->norm + 3*15, cn, -cn, cn ); ELL_3V_SET( pld->norm + 3*9, cn, -cn, cn ); /* 2 */ ELL_3V_SET( pld->norm + 3*2, -cn, -cn, cn ); ELL_3V_SET( pld->norm + 3*16, -cn, -cn, cn ); ELL_3V_SET( pld->norm + 3*12, -cn, -cn, cn ); /* 3 */ ELL_3V_SET( pld->norm + 3*3, -cn, cn, cn ); ELL_3V_SET( pld->norm + 3*6, -cn, cn, cn ); ELL_3V_SET( pld->norm + 3*19, -cn, cn, cn ); /* 4 */ ELL_3V_SET( pld->norm + 3*5, cn, cn, -cn ); ELL_3V_SET( pld->norm + 3*11, cn, cn, -cn ); ELL_3V_SET( pld->norm + 3*23, cn, cn, -cn ); /* 5 */ ELL_3V_SET( pld->norm + 3*10, cn, -cn, -cn ); ELL_3V_SET( pld->norm + 3*14, cn, -cn, -cn ); ELL_3V_SET( pld->norm + 3*20, cn, -cn, -cn ); /* 6 */ ELL_3V_SET( pld->norm + 3*17, -cn, -cn, -cn ); ELL_3V_SET( pld->norm + 3*21, -cn, -cn, -cn ); ELL_3V_SET( pld->norm + 3*13, -cn, -cn, -cn ); /* 7 */ ELL_3V_SET( pld->norm + 3*7, -cn, cn, -cn ); ELL_3V_SET( pld->norm + 3*22, -cn, cn, -cn ); ELL_3V_SET( pld->norm + 3*18, -cn, cn, -cn ); } else { ELL_3V_SET( pld->norm + 3*0, 0, 0, 1 ); /* 0 */ ELL_3V_SET( pld->norm + 3*1, 0, 1, 0 ); /* 1 */ ELL_3V_SET( pld->norm + 3*2, 1, 0, 0 ); /* 2 */ ELL_3V_SET( pld->norm + 3*3, 0, -1, 0 ); /* 3 */ ELL_3V_SET( pld->norm + 3*4, -1, 0, 0 ); /* 4 */ ELL_3V_SET( pld->norm + 3*5, 0, 0, -1 ); /* 5 */ } } if ( ( 1 << limnPolyDataInfoRGBA ) & infoBitFlag ) { for ( vertIdx=0; vertIdx<pld->rgbaNum; vertIdx++ ) { ELL_4V_SET( pld->rgba + 4*vertIdx, 255, 255, 255, 255 ); } } return 0; } int 462 limnPolyDataCylinder( limnPolyData *pld, unsigned int infoBitFlag, unsigned int thetaRes, int sharpEdge ) { static const char me[]="limnPolyDataCylinder"; unsigned int vertNum, primNum, primIdx, indxNum, thetaIdx, vertIdx, blah; double theta, cth, sth, sq2; /* sanity bounds */ thetaRes = AIR_MAX( 3, thetaRes ); vertNum = sharpEdge ? 4*thetaRes : 2*thetaRes; primNum = 3; indxNum = 2*thetaRes + 2*( thetaRes+1 ); /* 2 fans + 1 strip */ if ( limnPolyDataAlloc( pld, infoBitFlag, vertNum, indxNum, primNum ) ) { biffAddf( LIMN, "%s: couldn't allocate output", me ); return 1; } vertIdx = 0; for ( blah=0; blah < ( sharpEdge ? 2u : 1u ); blah++ ) { for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { theta = AIR_AFFINE( 0, thetaIdx, thetaRes, 0, 2*AIR_PI ); ELL_4V_SET_TT( pld->xyzw + 4*vertIdx, float, cos( theta ), sin( theta ), 1, 1 ); /* fprintf( stderr, "!%s: vert[%u] = %g %g %g\n", me, vertIdx, ( pld->xyzw + 4*vertIdx )[0], ( pld->xyzw + 4*vertIdx )[1], ( pld->xyzw + 4*vertIdx )[2] ); */ ++vertIdx; } } for ( blah=0; blah < ( sharpEdge ? 2u : 1u ); blah++ ) { for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { theta = AIR_AFFINE( 0, thetaIdx, thetaRes, 0, 2*AIR_PI ); ELL_4V_SET_TT( pld->xyzw + 4*vertIdx, float, cos( theta ), sin( theta ), -1, 1 ); /* fprintf( stderr, "!%s: vert[%u] = %g %g %g\n", me, vertIdx, ( pld->xyzw + 4*vertIdx )[0], ( pld->xyzw + 4*vertIdx )[1], ( pld->xyzw + 4*vertIdx )[2] ); */ ++vertIdx; } } primIdx = 0; vertIdx = 0; /* fan on top */ /* fprintf( stderr, "!%s: fan on top:\n", me ); */ for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { /* fprintf( stderr, "!%s: indx[%u] = %u\n", me, vertIdx, thetaIdx ); */ pld->indx[vertIdx++] = thetaIdx; } pld->type[primIdx] = limnPrimitiveTriangleFan; pld->icnt[primIdx] = thetaRes; primIdx++; /* single strip around */ /* fprintf( stderr, "!%s: strip around:\n", me ); */ for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { /* fprintf( stderr, "!%s: indx[%u] = %u\n", me, vertIdx, ( sharpEdge ? 1 : 0 )*thetaRes + thetaIdx ); */ pld->indx[vertIdx++] = ( sharpEdge ? 1 : 0 )*thetaRes + thetaIdx; /* fprintf( stderr, "!%s: indx[%u] = %u\n", me, vertIdx, ( sharpEdge ? 2 : 1 )*thetaRes + thetaIdx ); */ pld->indx[vertIdx++] = ( sharpEdge ? 2 : 1 )*thetaRes + thetaIdx; } /* fprintf( stderr, "!%s: indx[%u] = %u\n", me, vertIdx, ( sharpEdge ? 1 : 0 )*thetaRes ); */ pld->indx[vertIdx++] = ( sharpEdge ? 1 : 0 )*thetaRes; /* fprintf( stderr, "!%s: indx[%u] = %u\n", me, vertIdx, ( sharpEdge ? 2 : 1 )*thetaRes ); */ pld->indx[vertIdx++] = ( sharpEdge ? 2 : 1 )*thetaRes; pld->type[primIdx] = limnPrimitiveTriangleStrip; pld->icnt[primIdx] = 2*( thetaRes+1 ); primIdx++; /* fan on bottom */ /* fprintf( stderr, "!%s: fan on bottom:\n", me ); */ for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { /* fprintf( stderr, "!%s: indx[%u] = %u\n", me, vertIdx, ( sharpEdge ? 3 : 1 )*thetaRes + thetaIdx ); */ pld->indx[vertIdx++] = ( sharpEdge ? 3 : 1 )*thetaRes + thetaIdx; } pld->type[primIdx] = limnPrimitiveTriangleFan; pld->icnt[primIdx] = thetaRes; primIdx++; if ( ( 1 << limnPolyDataInfoNorm ) & infoBitFlag ) { sq2 = sqrt( 2.0 ); if ( sharpEdge ) { for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { theta = AIR_AFFINE( 0, thetaIdx, thetaRes, 0, 2*AIR_PI ); cth = cos( theta ); sth = sin( theta ); ELL_3V_SET_TT( pld->norm + 3*( thetaIdx + 0*thetaRes ), float, 0, 0, 1 ); ELL_3V_SET_TT( pld->norm + 3*( thetaIdx + 1*thetaRes ), float, cth, sth, 0 ); ELL_3V_SET_TT( pld->norm + 3*( thetaIdx + 2*thetaRes ), float, cth, sth, 0 ); ELL_3V_SET_TT( pld->norm + 3*( thetaIdx + 3*thetaRes ), float, 0, 0, -1 ); } } else { for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { theta = AIR_AFFINE( 0, thetaIdx, thetaRes, 0, 2*AIR_PI ); cth = sq2*cos( theta ); sth = sq2*sin( theta ); ELL_3V_SET_TT( pld->norm + 3*( thetaIdx + 0*thetaRes ), float, cth, sth, sq2 ); ELL_3V_SET_TT( pld->norm + 3*( thetaIdx + 1*thetaRes ), float, cth, sth, -sq2 ); } } } if ( ( 1 << limnPolyDataInfoTex2 ) & infoBitFlag ) { if ( sharpEdge ) { for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { theta = AIR_AFFINE( 0, thetaIdx, thetaRes, 0, 1 ); ELL_2V_SET_TT( pld->tex2 + 2*( thetaIdx + 0*thetaRes ), float, theta, 0 ); ELL_2V_SET_TT( pld->tex2 + 2*( thetaIdx + 1*thetaRes ), float, theta, 0 ); ELL_2V_SET_TT( pld->tex2 + 2*( thetaIdx + 2*thetaRes ), float, theta, 1 ); ELL_2V_SET_TT( pld->tex2 + 2*( thetaIdx + 3*thetaRes ), float, theta, 1 ); } } else { for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { theta = AIR_AFFINE( 0, thetaIdx, thetaRes, 0, 1 ); ELL_2V_SET_TT( pld->tex2 + 2*( thetaIdx + 0*thetaRes ), float, theta, 0 ); ELL_2V_SET_TT( pld->tex2 + 2*( thetaIdx + 1*thetaRes ), float, theta, 1 ); } } } if ( ( 1 << limnPolyDataInfoTang ) & infoBitFlag ) { float xx, yy, tang[3], tlen; if ( sharpEdge ) { for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { xx = ( pld->xyzw + 4*( thetaIdx + 0*thetaRes ) )[0]; yy = ( pld->xyzw + 4*( thetaIdx + 0*thetaRes ) )[1]; ELL_3V_SET( tang, -yy, xx, 0.0 ); ELL_3V_NORM_TT( tang, float, tang, tlen ); ELL_3V_COPY( pld->tang + 3*( thetaIdx + 0*thetaRes ), tang ); ELL_3V_COPY( pld->tang + 3*( thetaIdx + 1*thetaRes ), tang ); ELL_3V_COPY( pld->tang + 3*( thetaIdx + 2*thetaRes ), tang ); ELL_3V_COPY( pld->tang + 3*( thetaIdx + 3*thetaRes ), tang ); } } else { for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { xx = ( pld->xyzw + 4*( thetaIdx + 0*thetaRes ) )[0]; yy = ( pld->xyzw + 4*( thetaIdx + 0*thetaRes ) )[1]; ELL_3V_SET( tang, -yy, xx, 0.0 ); ELL_3V_NORM_TT( tang, float, tang, tlen ); ELL_3V_COPY( pld->tang + 3*( thetaIdx + 0*thetaRes ), tang ); ELL_3V_COPY( pld->tang + 3*( thetaIdx + 1*thetaRes ), tang ); } } } if ( ( 1 << limnPolyDataInfoRGBA ) & infoBitFlag ) { for ( vertIdx=0; vertIdx<pld->rgbaNum; vertIdx++ ) { ELL_4V_SET( pld->rgba + 4*vertIdx, 255, 255, 255, 255 ); } } return 0; } int 645 limnPolyDataCone( limnPolyData *pld, unsigned int infoBitFlag, unsigned int thetaRes, int sharpEdge ) { static const char me[]="limnPolyDataCone"; unsigned int vertNum, primNum, primIdx, indxNum, thetaIdx, vertIdx, blah; double theta, cth, sth; /* sanity bounds */ thetaRes = AIR_MAX( 3, thetaRes ); vertNum = sharpEdge ? 3*thetaRes : 1 + thetaRes; primNum = 2; indxNum = thetaRes + 2*( thetaRes+1 ); /* 1 fans + 1 strip */ if ( limnPolyDataAlloc( pld, infoBitFlag, vertNum, indxNum, primNum ) ) { biffAddf( LIMN, "%s: couldn't allocate output", me ); return 1; } /* top point( s ) */ vertIdx = 0; if ( sharpEdge ) { for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { ELL_4V_SET_TT( pld->xyzw + 4*vertIdx, float, 0, 0, 1, 1 ); ++vertIdx; } } else { ELL_4V_SET_TT( pld->xyzw + 4*vertIdx, float, 0, 0, 1, 1 ); ++vertIdx; } /* bottom edge */ for ( blah=0; blah < ( sharpEdge ? 2u : 1u ); blah++ ) { for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { theta = AIR_AFFINE( 0, thetaIdx, thetaRes, 0, 2*AIR_PI ); ELL_4V_SET_TT( pld->xyzw + 4*vertIdx, float, cos( theta ), sin( theta ), -1, 1 ); ++vertIdx; } } primIdx = 0; vertIdx = 0; /* single strip around */ for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { pld->indx[vertIdx++] = sharpEdge ? thetaIdx : 0; pld->indx[vertIdx++] = ( sharpEdge ? thetaRes : 1 ) + thetaIdx; } pld->indx[vertIdx++] = 0; pld->indx[vertIdx++] = sharpEdge ? thetaRes : 1; pld->type[primIdx] = limnPrimitiveTriangleStrip; pld->icnt[primIdx] = 2*( thetaRes+1 ); primIdx++; /* fan on bottom */ for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { pld->indx[vertIdx++] = ( sharpEdge ? 2*thetaRes : 1 ) + thetaIdx; } pld->type[primIdx] = limnPrimitiveTriangleFan; pld->icnt[primIdx] = thetaRes; primIdx++; if ( ( 1 << limnPolyDataInfoNorm ) & infoBitFlag ) { double isq3; isq3 = 1/sqrt( 3.0 ); if ( sharpEdge ) { for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { theta = AIR_AFFINE( 0, thetaIdx, thetaRes, 0, 2*AIR_PI ); cth = cos( theta ); sth = sin( theta ); ELL_3V_SET_TT( pld->norm + 3*( thetaIdx + 0*thetaRes ), float, cth*isq3, sth*isq3, isq3 ); ELL_3V_SET_TT( pld->norm + 3*( thetaIdx + 1*thetaRes ), float, cth*isq3, sth*isq3, isq3 ); ELL_3V_SET_TT( pld->norm + 3*( thetaIdx + 2*thetaRes ), float, 0, 0, -1 ); } } else { ELL_3V_SET_TT( pld->norm + 3*( 0 ), float, 0, 0, 1 ); for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { theta = AIR_AFFINE( 0, thetaIdx, thetaRes, 0, 2*AIR_PI ); cth = cos( theta ); sth = sin( theta ); ELL_3V_SET_TT( pld->norm + 3*( thetaIdx + 1 ), float, cth*isq3, sth*isq3, -isq3 ); /* close enough */ } } } if ( ( 1 << limnPolyDataInfoRGBA ) & infoBitFlag ) { for ( vertIdx=0; vertIdx<pld->rgbaNum; vertIdx++ ) { ELL_4V_SET( pld->rgba + 4*vertIdx, 255, 255, 255, 255 ); } } return 0; } /* ******** limnPolyDataSuperquadric ** ** makes a superquadric parameterized around the Z axis */ int 750 limnPolyDataSuperquadric( limnPolyData *pld, unsigned int infoBitFlag, float alpha, float beta, unsigned int thetaRes, unsigned int phiRes ) { static const char me[]="limnPolyDataSuperquadric"; unsigned int vertIdx, vertNum, fanNum, stripNum, primNum, indxNum, thetaIdx, phiIdx, primIdx; double theta, phi; /* sanity bounds */ thetaRes = AIR_MAX( 3u, thetaRes ); phiRes = AIR_MAX( 2u, phiRes ); alpha = AIR_MAX( 0.00001f, alpha ); beta = AIR_MAX( 0.00001f, beta ); vertNum = 2 + thetaRes*( phiRes-1 ); fanNum = 2; stripNum = phiRes-2; primNum = fanNum + stripNum; indxNum = ( thetaRes+2 )*fanNum + 2*( thetaRes+1 )*stripNum; if ( limnPolyDataAlloc( pld, infoBitFlag, vertNum, indxNum, primNum ) ) { biffAddf( LIMN, "%s: couldn't allocate output", me ); return 1; } vertIdx = 0; ELL_4V_SET( pld->xyzw + 4*vertIdx, 0, 0, 1, 1 ); if ( ( 1 << limnPolyDataInfoNorm ) & infoBitFlag ) { ELL_3V_SET( pld->norm + 3*vertIdx, 0, 0, 1 ); } ++vertIdx; for ( phiIdx=1; phiIdx<phiRes; phiIdx++ ) { double cost, sint, cosp, sinp; phi = AIR_AFFINE( 0, phiIdx, phiRes, 0, AIR_PI ); cosp = cos( phi ); sinp = sin( phi ); for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { theta = AIR_AFFINE( 0, thetaIdx, thetaRes, 0, 2*AIR_PI ); cost = cos( theta ); sint = sin( theta ); ELL_4V_SET_TT( pld->xyzw + 4*vertIdx, float, airSgnPow( cost, alpha ) * airSgnPow( sinp, beta ), airSgnPow( sint, alpha ) * airSgnPow( sinp, beta ), airSgnPow( cosp, beta ), 1.0 ); if ( ( 1 << limnPolyDataInfoNorm ) & infoBitFlag ) { if ( 1 == alpha && 1 == beta ) { ELL_3V_COPY( pld->norm + 3*vertIdx, pld->xyzw + 4*vertIdx ); } else { ELL_3V_SET_TT( pld->norm + 3*vertIdx, float, 2*airSgnPow( cost, 2-alpha )*airSgnPow( sinp, 2-beta )/beta, 2*airSgnPow( sint, 2-alpha )*airSgnPow( sinp, 2-beta )/beta, 2*airSgnPow( cosp, 2-beta )/beta ); } } ++vertIdx; } } ELL_4V_SET( pld->xyzw + 4*vertIdx, 0, 0, -1, 1 ); if ( ( 1 << limnPolyDataInfoNorm ) & infoBitFlag ) { ELL_3V_SET( pld->norm + 3*vertIdx, 0, 0, -1 ); } ++vertIdx; /* triangle fan at top */ vertIdx = 0; primIdx = 0; pld->indx[vertIdx++] = 0; for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { pld->indx[vertIdx++] = thetaIdx + 1; } pld->indx[vertIdx++] = 1; pld->type[primIdx] = limnPrimitiveTriangleFan; pld->icnt[primIdx++] = thetaRes + 2; /* tristrips around */ for ( phiIdx=1; phiIdx<phiRes-1; phiIdx++ ) { /* fprintf( stderr, "!%s: prim[%u] = vert[%u] =", me, primIdx, vertIdx ); */ for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { /* fprintf( stderr, " [%u %u] %u %u", vertIdx, vertIdx + 1, ( phiIdx-1 )*thetaRes + thetaIdx + 1, phiIdx*thetaRes + thetaIdx + 1 ); */ pld->indx[vertIdx++] = ( phiIdx-1 )*thetaRes + thetaIdx + 1; pld->indx[vertIdx++] = phiIdx*thetaRes + thetaIdx + 1; } /* fprintf( stderr, " [%u %u] %u %u ( %u verts )\n", vertIdx, vertIdx + 1, ( phiIdx-1 )*thetaRes + 1, phiIdx*thetaRes + 1, 2*( thetaRes+1 ) ); */ pld->indx[vertIdx++] = ( phiIdx-1 )*thetaRes + 1; pld->indx[vertIdx++] = phiIdx*thetaRes + 1; pld->type[primIdx] = limnPrimitiveTriangleStrip; pld->icnt[primIdx++] = 2*( thetaRes+1 ); } /* triangle fan at bottom */ pld->indx[vertIdx++] = vertNum-1; for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { pld->indx[vertIdx++] = thetaRes*( phiRes-2 ) + thetaRes - thetaIdx; } pld->indx[vertIdx++] = thetaRes*( phiRes-2 ) + thetaRes; pld->type[primIdx] = limnPrimitiveTriangleFan; pld->icnt[primIdx++] = thetaRes + 2; if ( ( 1 << limnPolyDataInfoRGBA ) & infoBitFlag ) { for ( vertIdx=0; vertIdx<pld->rgbaNum; vertIdx++ ) { ELL_4V_SET( pld->rgba + 4*vertIdx, 255, 255, 255, 255 ); } } return 0; } /* ******** limnPolyDataSpiralBetterquadric ** ** puts a "betterquadric" into a single spiral triangle strip */ int 876 limnPolyDataSpiralBetterquadric( limnPolyData *pld, unsigned int infoBitFlag, float alpha, float beta, float cee, float minRad, unsigned int thetaRes, unsigned int phiRes ) { static const char me[]="limnPolyDataSpiralBetterquadric"; unsigned int vertIdx, vertNum, indxNum, thetaIdx, phiIdx; /* sanity bounds */ thetaRes = AIR_MAX( 3u, thetaRes ); phiRes = AIR_MAX( 2u, phiRes ); alpha = AIR_MAX( 0.00001f, alpha ); beta = AIR_MAX( 0.00001f, beta ); vertNum = thetaRes*phiRes + 1; indxNum = 2*thetaRes*( phiRes+1 ) - 2; if ( limnPolyDataAlloc( pld, infoBitFlag, vertNum, indxNum, 1 ) ) { biffAddf( LIMN, "%s: couldn't allocate output", me ); return 1; } vertIdx = 0; for ( phiIdx=0; phiIdx<phiRes; phiIdx++ ) { for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { double cost, sint, cosp, sinp, xx, yy, zz; double phi = ( AIR_AFFINE( 0, phiIdx, phiRes, 0, AIR_PI ) + AIR_AFFINE( 0, thetaIdx, thetaRes, 0, AIR_PI )/phiRes ); double theta = AIR_AFFINE( 0, thetaIdx, thetaRes, 0.0, 2*AIR_PI ); cosp = cos( phi ); sinp = sin( phi ); cost = cos( theta ); sint = sin( theta ); xx = airSgnPow( cost, alpha ) * airSgnPow( sinp, beta ); yy = airSgnPow( sint, alpha ) * airSgnPow( sinp, beta ); zz = airSgnPow( cosp, beta ); if ( cee != beta ) { /* expand profile along y axis to match having beta=cee */ double yp, ymax; yp = airSgnPow( sin( acos( airSgnPow( zz, 1/cee ) ) ), cee ); ymax = airSgnPow( sinp, beta ); if ( ymax ) { yy *= yp/ymax; } } ELL_4V_SET_TT( pld->xyzw + 4*vertIdx, float, xx, yy, zz, 1.0 ); if ( minRad > 0.0 ) { /* add thickness to small radius */ double rr; xx = ( pld->xyzw + 4*vertIdx )[0]; yy = ( pld->xyzw + 4*vertIdx )[1]; rr = sqrt( xx*xx + yy*yy ); if ( rr ) { ( pld->xyzw + 4*vertIdx )[0] *= AIR_CAST( float, AIR_AFFINE( 0, rr, 1, minRad/rr, 1/rr ) ); ( pld->xyzw + 4*vertIdx )[1] *= AIR_CAST( float, AIR_AFFINE( 0, rr, 1, minRad/rr, 1/rr ) ); } } if ( ( ( 1 << limnPolyDataInfoNorm ) & infoBitFlag ) || ( ( 1 << limnPolyDataInfoTang ) & infoBitFlag ) ) { double norm[3], nlen; if ( 1 == alpha && 1 == beta ) { ELL_3V_COPY( norm, pld->xyzw + 4*vertIdx ); } else { if ( !vertIdx ) { ELL_3V_SET( norm, 0.0, 0.0, 1.0 ); } else { ELL_3V_SET( norm, ( 2*airSgnPow( cost, 2-alpha )*airSgnPow( sinp, 2-beta )/beta ), ( 2*airSgnPow( sint, 2-alpha )*airSgnPow( sinp, 2-beta )/beta ), 2*airSgnPow( cosp, 2-beta )/beta ); } } if ( ( nlen = ELL_3V_LEN( norm ) ) ) { ELL_3V_SCALE( norm, 1.0/nlen, norm ); } else { ELL_3V_SET( norm, 0.0, 0.0, 1.0 ); } if ( ( 1 << limnPolyDataInfoNorm ) & infoBitFlag ) { ELL_3V_COPY_TT( pld->norm + 3*vertIdx, float, norm ); } if ( ( 1 << limnPolyDataInfoTang ) & infoBitFlag ) { double tang[3], tlen; ELL_3V_SET( tang, -norm[1], norm[0], 0.0 ); if ( ( tlen = ELL_3V_LEN( tang ) ) ) { ELL_3V_SCALE( tang, 1.0/tlen, tang ); } else { ELL_3V_SET( tang, 1.0, 0.0, 0.0 ); } ELL_3V_COPY_TT( pld->tang + 3*vertIdx, float, tang ); } } if ( ( 1 << limnPolyDataInfoTex2 ) & infoBitFlag ) { ELL_2V_SET_TT( pld->tex2 + 2*vertIdx, float, AIR_AFFINE( 0.0, theta, 2*AIR_PI, 0.0, 1.0 ), AIR_AFFINE( 0.0, phi, AIR_PI, 0.0, 1.0 ) ); } ++vertIdx; } } ELL_4V_SET( pld->xyzw + 4*vertIdx, 0, 0, -1, 1 ); if ( ( 1 << limnPolyDataInfoNorm ) & infoBitFlag ) { ELL_3V_SET( pld->norm + 3*vertIdx, 0.0, 0.0, -1.0 ); } if ( ( 1 << limnPolyDataInfoTex2 ) & infoBitFlag ) { ELL_2V_SET( pld->tex2 + 2*vertIdx, 0.5, 1.0 ); } if ( ( 1 << limnPolyDataInfoTang ) & infoBitFlag ) { ELL_3V_SET( pld->tang + 3*vertIdx, 1.0, 0.0, 0.0 ); } ++vertIdx; /* single triangle strip */ pld->type[0] = limnPrimitiveTriangleStrip; pld->icnt[0] = indxNum; vertIdx = 0; for ( thetaIdx=1; thetaIdx<thetaRes; thetaIdx++ ) { pld->indx[vertIdx++] = 0; pld->indx[vertIdx++] = thetaIdx; } for ( phiIdx=0; phiIdx<phiRes-1; phiIdx++ ) { for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { pld->indx[vertIdx++] = ( ( phiIdx + 0 ) * thetaRes ) + thetaIdx; pld->indx[vertIdx++] = ( ( phiIdx + 1 ) * thetaRes ) + thetaIdx; } } for ( thetaIdx=0; thetaIdx<thetaRes; thetaIdx++ ) { pld->indx[vertIdx++] = ( phiRes - 1 )*thetaRes + thetaIdx; pld->indx[vertIdx++] = ( phiRes - 0 )*thetaRes; } #if 0 if ( ( cee != beta || minRad > 0.0 ) && ( ( 1 << limnPolyDataInfoNorm ) & infoBitFlag ) ) { /* have deformed object in some way that confounds analytic normals */ if ( limnPolyDataVertexNormals( pld ) ) { biffAddf( LIMN, "%s: trouble getting normals", me ); return 1; } } #endif if ( ( 1 << limnPolyDataInfoRGBA ) & infoBitFlag ) { for ( vertIdx=0; vertIdx<pld->rgbaNum; vertIdx++ ) { ELL_4V_SET( pld->rgba + 4*vertIdx, 255, 255, 255, 255 ); } } return 0; } /* ******** limnPolyDataSpiralSuperquadric ** ** puts a superquadric into a single spiral triangle strip */ int 1028 limnPolyDataSpiralSuperquadric( limnPolyData *pld, unsigned int infoBitFlag, float alpha, float beta, unsigned int thetaRes, unsigned int phiRes ) { static const char me[]="limnPolyDataSpiralSuperquadric"; if ( limnPolyDataSpiralBetterquadric( pld, infoBitFlag, alpha, beta, beta, 0.0, thetaRes, phiRes ) ) { biffAddf( LIMN, "%s: trouble", me ); return 1; } return 0; } /* ******** limnPolyDataPolarSphere ** ** makes a unit sphere, centered at the origin, parameterized around Z axis */ int 1048 limnPolyDataPolarSphere( limnPolyData *pld, unsigned int infoBitFlag, unsigned int thetaRes, unsigned int phiRes ) { static const char me[]="limnPolyDataPolarSphere"; if ( limnPolyDataSuperquadric( pld, infoBitFlag, 1.0, 1.0, thetaRes, phiRes ) ) { biffAddf( LIMN, "%s: trouble", me ); return 1; } return 0; } int 1062 limnPolyDataSpiralSphere( limnPolyData *pld, unsigned int infoBitFlag, unsigned int thetaRes, unsigned int phiRes ) { static const char me[]="limnPolyDataSpiralSphere"; if ( limnPolyDataSpiralSuperquadric( pld, infoBitFlag, 1.0, 1.0, thetaRes, phiRes ) ) { biffAddf( LIMN, "%s: trouble", me ); return 1; } return 0; } /* Geometry for an icosahedron */ #define ICO_ONE 0.5257311121f #define ICO_TAU 0.8506508084f static float icovertices[36] = { 0.0f, ICO_ONE, ICO_TAU, 0.0f, -ICO_ONE, -ICO_TAU, 0.0f, -ICO_ONE, ICO_TAU, 0.0f, ICO_ONE, -ICO_TAU, ICO_ONE, ICO_TAU, 0.0f, -ICO_ONE, -ICO_TAU, 0.0f, ICO_ONE, -ICO_TAU, 0.0f, -ICO_ONE, ICO_TAU, 0.0f, ICO_TAU, 0.0f, ICO_ONE, -ICO_TAU, 0.0f, -ICO_ONE, -ICO_TAU, 0.0f, ICO_ONE, ICO_TAU, 0.0f, -ICO_ONE }; #undef ICO_ONE #undef ICO_TAU static unsigned int icoedges[60] = { 0, 2, 1, 3, 0, 4, 1, 5, 0, 8, 1, 9, 0, 10, 1, 11, /* 0-7 */ 0, 7, 1, 6, 2, 6, 3, 7, 2, 8, 3, 9, 2, 10, 3, 11, /* 8-15 */ 2, 5, 3, 4, 4, 8, 5, 9, 4, 7, 5, 6, 4, 11, 5, 10, /* 16-23*/ 6, 8, 7, 9, 6, 11, 7, 10, 8, 11, 9, 10 /* 24-29 */ }; static unsigned int icofaces[60] = { 0, 4, 12, 1, 5, 13, 0, 6, 14, 1, 7, 15, 6, 8, 27, 7, 9, 26, 2, 4, 18, 3, 5, 19, 10, 12, 24, 11, 13, 25, 14, 16, 23, 15, 17, 22, 2, 8, 20, 3, 9, 21, 10, 16, 21, 11, 17, 20, 24, 26, 28, 25, 27, 29, 18, 22, 28, 19, 23, 29 }; /* ******** limnPolyDataIcoSphere ** ** Makes a unit sphere, centered at the origin, by refining an icosahedron ** level times. Each refinement step subdivides each edge at its center, ** turning each triangle into four smaller ones. ** ** In the output, vertex 2*i and 2*i+1 are antipodal points, which allows for ** a more efficient implementation of operations that produce the same or ** a mirrored result for antipodal points ( e.g., tensor glyphs ). */ int 1118 limnPolyDataIcoSphere( limnPolyData *pld, unsigned int infoBitFlag, unsigned int level ) { static const char me[]="limnPolyDataIcoSphere"; unsigned int vertNum=12, edgeNum=30, faceNum=20, center; float *verts, *xyzwp, *vertp; unsigned char *rgbap; unsigned int *edges, *faces; unsigned int i, e, f; /* loop counters */ airArray *mop; /* free memory in case of allocation error */ /* sanity checks */ if ( !pld ) { biffAddf( LIMN, "%s: got NULL pointer", me ); return 1; } mop = airMopNew( ); /* x/y/z positions */ verts = ( float * ) malloc ( sizeof( float )*12*3 ); if ( verts==NULL ) goto error_and_exit; airMopAdd( mop, verts, airFree, airMopAlways ); memcpy( verts, icovertices, sizeof( float )*12*3 ); /* endpoints for each edge */ edges = ( unsigned int * ) malloc ( sizeof( unsigned int )*30*2 ); if ( edges==NULL ) goto error_and_exit; airMopAdd( mop, edges, airFree, airMopAlways ); memcpy( edges, icoedges, sizeof( unsigned int )*60 ); /* vertices of each face */ faces = ( unsigned int * ) malloc ( sizeof( unsigned int )*20*3 ); if ( faces==NULL ) goto error_and_exit; airMopAdd( mop, faces, airFree, airMopAlways ); memcpy( faces, icofaces, sizeof( unsigned int )*60 ); for ( i=0; i<level; ++i ) { /* subdivision step */ unsigned int nvertNum=vertNum+edgeNum; unsigned int nedgeNum=2*edgeNum+3*faceNum; unsigned int nfaceNum=4*faceNum; float *newverts; unsigned int *newedges, *newfaces; newverts = ( float * ) malloc( sizeof( float )*3*nvertNum ); if ( newverts==NULL ) goto error_and_exit; airMopAdd( mop, newverts, airFree, airMopAlways ); newedges = ( unsigned int * ) malloc( sizeof( unsigned int )*2*nedgeNum ); if ( newedges==NULL ) goto error_and_exit; airMopAdd( mop, newedges, airFree, airMopAlways ); newfaces = ( unsigned int * ) malloc( sizeof( unsigned int )*3*nfaceNum ); if ( newfaces==NULL ) goto error_and_exit; airMopAdd( mop, newfaces, airFree, airMopAlways ); memcpy( newverts, verts, sizeof( float )*3*vertNum ); for ( e=0; e<edgeNum; e+=2 ) { /* split both edge and anti-edge */ float norm; ELL_3V_ADD2( newverts+3*( vertNum+e ), verts+3*( edges[2*e] ), verts+3*( edges[2*e+1] ) ); /* project new vertex to unit sphere */ ELL_3V_NORM_TT( newverts+3*( vertNum+e ), float, newverts+3*( vertNum+e ), norm ); ELL_3V_SCALE_TT( newverts+3*( vertNum+e+1 ), float, -1.0, newverts+3*( vertNum+e ) ); /* split the edges such that anti-edge follows edge */ newedges[4*e]=edges[2*e]; newedges[4*e+1]=vertNum+e; newedges[4*e+2]=edges[2*e+2]; newedges[4*e+3]=vertNum+e+1; newedges[4*e+4]=vertNum+e; newedges[4*e+5]=edges[2*e+1]; newedges[4*e+6]=vertNum+e+1; newedges[4*e+7]=edges[2*e+3]; } for ( f=0; f<faceNum; f+=2 ) { /* split both face and anti-face */ unsigned int oldedge11=faces[3*f], oldedge12=faces[3*f+1], oldedge13=faces[3*f+2], oldedge21=faces[3*f+3], oldedge22=faces[3*f+4], oldedge23=faces[3*f+5]; unsigned int eidx=2*edgeNum+3*f; /* index of the first edge to add */ char pol11=0, pol12=0, pol13=0, pol21=0, pol22=0, pol23=0; /* polarity */ /* add three edges per face - anti-edge has to follow edge! */ newedges[2*eidx]=newedges[2*eidx+9]=vertNum+oldedge11; newedges[2*eidx+1]=newedges[2*eidx+4]=vertNum+oldedge12; newedges[2*eidx+5]=newedges[2*eidx+8]=vertNum+oldedge13; newedges[2*eidx+2]=newedges[2*eidx+11]=vertNum+oldedge21; newedges[2*eidx+3]=newedges[2*eidx+6]=vertNum+oldedge22; newedges[2*eidx+7]=newedges[2*eidx+10]=vertNum+oldedge23; /* split the faces - we do not have directed half-edges! * determine the "polarity" of the edges ( 0 forward / 2 backward ) */ if ( edges[2*oldedge11+1]==edges[2*oldedge13+1] || edges[2*oldedge11+1]==edges[2*oldedge13] ) pol11=2; if ( edges[2*oldedge12+1]==edges[2*oldedge11+1] || edges[2*oldedge12+1]==edges[2*oldedge11] ) pol12=2; if ( edges[2*oldedge13+1]==edges[2*oldedge12+1] || edges[2*oldedge13+1]==edges[2*oldedge12] ) pol13=2; if ( edges[2*oldedge21+1]==edges[2*oldedge23+1] || edges[2*oldedge21+1]==edges[2*oldedge23] ) pol21=2; if ( edges[2*oldedge22+1]==edges[2*oldedge21+1] || edges[2*oldedge22+1]==edges[2*oldedge21] ) pol22=2; if ( edges[2*oldedge23+1]==edges[2*oldedge22+1] || edges[2*oldedge23+1]==edges[2*oldedge22] ) pol23=2; newfaces[12*f] = 2*oldedge11-( oldedge11%2 )+pol11; /* bottom/left */ newfaces[12*f+1] = eidx+4; newfaces[12*f+2] = 2*oldedge13-( oldedge13%2 )+2-pol13; newfaces[12*f+3] = 2*oldedge21-( oldedge21%2 )+pol21; /* anti */ newfaces[12*f+4] = eidx+5; newfaces[12*f+5] = 2*oldedge23-( oldedge23%2 )+2-pol23; newfaces[12*f+6] = 2*oldedge11-( oldedge11%2 )+2-pol11; /* bottom/right */ newfaces[12*f+7] = 2*oldedge12-( oldedge12%2 )+pol12; newfaces[12*f+8] = eidx; newfaces[12*f+9] = 2*oldedge21-( oldedge21%2 )+2-pol21; /* anti */ newfaces[12*f+10]= 2*oldedge22-( oldedge22%2 )+pol22; newfaces[12*f+11]= eidx+1; newfaces[12*f+12]= 2*oldedge12-( oldedge12%2 )+2-pol12; /* top */ newfaces[12*f+13]= 2*oldedge13-( oldedge13%2 )+pol13; newfaces[12*f+14]= eidx+2; newfaces[12*f+15]= 2*oldedge22-( oldedge22%2 )+2-pol22; /* anti */ newfaces[12*f+16]= 2*oldedge23-( oldedge23%2 )+pol23; newfaces[12*f+17]= eidx+3; newfaces[12*f+18]= eidx; /* center */ newfaces[12*f+19]= eidx+2; newfaces[12*f+20]= eidx+4; newfaces[12*f+21]= eidx+1; /* anti */ newfaces[12*f+22]= eidx+3; newfaces[12*f+23]= eidx+5; } /* make subdivided mesh the current one */ airMopSub( mop, verts, airFree ); airMopSub( mop, edges, airFree ); airMopSub( mop, faces, airFree ); free( verts ); free( edges ); free( faces ); verts=newverts; edges=newedges; faces=newfaces; vertNum=nvertNum; edgeNum=nedgeNum; faceNum=nfaceNum; } /* done; now copy to a limnPolyData struct */ if ( limnPolyDataAlloc( pld, infoBitFlag, vertNum, 3*faceNum, 1 ) ) { biffAddf( LIMN, "%s: couldn't allocate output", me ); return 1; } xyzwp=pld->xyzw; vertp=verts; for ( i=0; i<vertNum; i++ ) { ELL_4V_SET( xyzwp, vertp[0], vertp[1], vertp[2], 1.0 ); xyzwp+=4; vertp+=3; } if ( ( 1 << limnPolyDataInfoNorm ) & infoBitFlag ) { /* normals equal the vertex coordinates */ memcpy( pld->norm, verts, sizeof( float )*3*vertNum ); } if ( ( 1 << limnPolyDataInfoRGBA ) & infoBitFlag ) { rgbap=pld->rgba; vertp=verts; for ( i=0; i<vertNum; i++ ) { ELL_4V_SET_TT( rgbap, unsigned char, 255, 255, 255, 255 ); rgbap+=4; vertp+=3; } } if ( ( 1 << limnPolyDataInfoTex2 ) & infoBitFlag ) { for ( i=0; i<vertNum; i++ ) { double rr, xyz[3], phi, theta; ELL_3V_COPY( xyz, pld->xyzw + 4*i ); rr = sqrt( xyz[0]*xyz[0] + xyz[1]*xyz[1] ); phi = atan2( rr, xyz[2] ); theta = atan2( xyz[1], xyz[0] ); ELL_2V_SET_TT( pld->tex2 + 2*i, float, AIR_AFFINE( -AIR_PI, theta, AIR_PI, 0.0, 1.0 ), AIR_AFFINE( 0.0, phi, AIR_PI, 0.0, 1.0 ) ); } } if ( ( 1 << limnPolyDataInfoTang ) & infoBitFlag ) { for ( i=0; i<vertNum; i++ ) { double rr, xyz[3], tang[3], len; ELL_3V_COPY( xyz, pld->xyzw + 4*i ); rr = sqrt( xyz[0]*xyz[0] + xyz[1]*xyz[1] ); if ( rr ) { ELL_3V_SET( tang, -xyz[1], xyz[0], 0.0 ); ELL_3V_NORM_TT( pld->tang + 3*i, float, tang, len ); } else { ELL_3V_SET( pld->tang + 3*i, 1.0f, 0.0f, 0.0f ); } } } /* We need to replace reference to edges in faces with references to * vertices. Make sure that they are ordered CCW */ pld->type[0] = limnPrimitiveTriangles; pld->icnt[0] = faceNum*3; for ( f=0; f<faceNum; ++f ) { unsigned int vertices[3]; /* find the right vertices */ float diff1[3], diff2[3], cross[3]; vertices[0]=edges[2*faces[3*f]]; vertices[1]=edges[2*faces[3*f]+1]; if ( edges[2*faces[3*f+1]]==vertices[0] || edges[2*faces[3*f+1]]==vertices[1] ) vertices[2]=edges[2*faces[3*f+1]+1]; else vertices[2]=edges[2*faces[3*f+1]]; /* put them into correct order */ ELL_3V_SUB( diff1, verts+3*vertices[1], verts+3*vertices[0] ); ELL_3V_SUB( diff2, verts+3*vertices[2], verts+3*vertices[0] ); ELL_3V_CROSS( cross, diff1, diff2 ); pld->indx[3*f]=vertices[0]; if ( ELL_3V_DOT( cross, verts+3*vertices[0] )<0 ) { pld->indx[3*f+1]=vertices[2]; pld->indx[3*f+2]=vertices[1]; } else { pld->indx[3*f+1]=vertices[1]; pld->indx[3*f+2]=vertices[2]; } } /* re-order the triangles */ center=3*( faceNum/2 ); for ( i=0; i<faceNum/2; i++ ) { ELL_3V_COPY( faces+3*i, pld->indx+6*i ); ELL_3V_COPY( faces+center+3*i, pld->indx+6*i+3 ); } airMopAdd( mop, pld->indx, airFree, airMopAlways ); airMopSub( mop, faces, airFree ); pld->indx=faces; /* done */ airMopOkay( mop ); return 0; error_and_exit: biffAddf( LIMN, "%s: memory allocation failed", me ); airMopError( mop ); return 1; } int 1350 limnPolyDataPlane( limnPolyData *pld, unsigned int infoBitFlag, unsigned int uRes, unsigned int vRes ) { static const char me[]="limnPolyDataPlane"; unsigned int vertNum, indxNum, primNum, uIdx, vIdx, vertIdx, primIdx; float uu, vv; /* sanity */ uRes = AIR_MAX( 2, uRes ); vRes = AIR_MAX( 2, vRes ); vertNum = uRes*vRes; primNum = vRes-1; indxNum = primNum*2*uRes; if ( limnPolyDataAlloc( pld, infoBitFlag, vertNum, indxNum, primNum ) ) { biffAddf( LIMN, "%s: couldn't allocate output", me ); return 1; } vertIdx = 0; for ( vIdx=0; vIdx<vRes; vIdx++ ) { vv = AIR_CAST( float, AIR_AFFINE( 0, vIdx, vRes-1, -1.0, 1.0 ) ); for ( uIdx=0; uIdx<uRes; uIdx++ ) { uu = AIR_CAST( float, AIR_AFFINE( 0, uIdx, uRes-1, -1.0, 1.0 ) ); ELL_4V_SET( pld->xyzw + 4*vertIdx, uu, vv, 0.0, 1.0 ); if ( ( 1 << limnPolyDataInfoNorm ) & infoBitFlag ) { ELL_3V_SET_TT( pld->norm + 3*vertIdx, float, 0.0, 0.0, 1.0 ); } if ( ( 1 << limnPolyDataInfoRGBA ) & infoBitFlag ) { ELL_4V_SET( pld->rgba + 4*vertIdx, 255, 255, 255, 255 ); } if ( ( 1 << limnPolyDataInfoTex2 ) & infoBitFlag ) { ELL_2V_SET_TT( pld->tex2 + 2*vertIdx, float, ( uu+1.0 )/2.0, ( vv+1.0 )/2.0 ); } if ( ( 1 << limnPolyDataInfoTang ) & infoBitFlag ) { ELL_3V_SET_TT( pld->tang + 3*vertIdx, float, 1.0, 0.0, 0.0 ); } ++vertIdx; } } vertIdx = 0; for ( primIdx=0; primIdx<primNum; primIdx++ ) { for ( uIdx=0; uIdx<uRes; uIdx++ ) { pld->indx[vertIdx++] = uIdx + uRes*( primIdx+1 ); pld->indx[vertIdx++] = uIdx + uRes*( primIdx ); } pld->type[primIdx] = limnPrimitiveTriangleStrip; pld->icnt[primIdx] = 2*uRes; } return 0; } int 1405 limnPolyDataSquare( limnPolyData *pld, unsigned int infoBitFlag ) { static const char me[]="limnPolyDataSquare"; if ( limnPolyDataAlloc( pld, infoBitFlag, 4, 4, 1 ) ) { biffAddf( LIMN, "%s: couldn't allocate output", me ); return 1; } ELL_4V_SET( pld->xyzw + 4*0, -1.0, -1.0, 0.0, 1.0 ); ELL_4V_SET( pld->xyzw + 4*1, 1.0, -1.0, 0.0, 1.0 ); ELL_4V_SET( pld->xyzw + 4*2, -1.0, 1.0, 0.0, 1.0 ); ELL_4V_SET( pld->xyzw + 4*3, 1.0, 1.0, 0.0, 1.0 ); if ( ( 1 << limnPolyDataInfoNorm ) & infoBitFlag ) { ELL_3V_SET( pld->norm + 3*0, 0.0, 0.0, 1.0 ); ELL_3V_SET( pld->norm + 3*1, 0.0, 0.0, 1.0 ); ELL_3V_SET( pld->norm + 3*2, 0.0, 0.0, 1.0 ); ELL_3V_SET( pld->norm + 3*3, 0.0, 0.0, 1.0 ); } if ( ( 1 << limnPolyDataInfoRGBA ) & infoBitFlag ) { ELL_4V_SET( pld->rgba + 4*0, 255, 255, 255, 255 ); ELL_4V_SET( pld->rgba + 4*1, 255, 255, 255, 255 ); ELL_4V_SET( pld->rgba + 4*2, 255, 255, 255, 255 ); ELL_4V_SET( pld->rgba + 4*3, 255, 255, 255, 255 ); } if ( ( 1 << limnPolyDataInfoTex2 ) & infoBitFlag ) { ELL_2V_SET( pld->tex2 + 2*0, 0.0, 1.0 ); ELL_2V_SET( pld->tex2 + 2*1, 1.0, 1.0 ); ELL_2V_SET( pld->tex2 + 2*2, 0.0, 0.0 ); ELL_2V_SET( pld->tex2 + 2*3, 1.0, 0.0 ); } if ( ( 1 << limnPolyDataInfoTang ) & infoBitFlag ) { ELL_3V_SET( pld->tang + 3*0, 1.0, 0.0, 0.0 ); ELL_3V_SET( pld->tang + 3*1, 1.0, 0.0, 0.0 ); ELL_3V_SET( pld->tang + 3*2, 1.0, 0.0, 0.0 ); ELL_3V_SET( pld->tang + 3*3, 1.0, 0.0, 0.0 ); } pld->type[0] = limnPrimitiveTriangleStrip; ELL_4V_SET( pld->indx, 0, 1, 2, 3 ); pld->icnt[0] = 4; return 0; } int 1448 limnPolyDataSuperquadric2D( limnPolyData *pld, unsigned int infoBitFlag, float alpha, unsigned int res ) { static const char me[]="limnPolyDataSuperquadric2D"; unsigned int i, vertNum; float phi; vertNum = res+1; /* initial vertex at origin */ if ( limnPolyDataAlloc( pld, infoBitFlag, vertNum, vertNum+1, /* last index wraps around */ 1 ) ) { biffAddf( LIMN, "%s: couldn't allocate output", me ); return 1; } /* initial vertex at origin */ ELL_4V_SET( pld->xyzw + 4*0, 0.0, 0.0, 0.0, 1.0 ); /* printf( "!%s: xyzw[0] = %g %g %g %g\n", me, ( pld->xyzw + 4*0 )[0], ( pld->xyzw + 4*0 )[1], ( pld->xyzw + 4*0 )[2], ( pld->xyzw + 4*0 )[3] ); */ for ( i=1; i<vertNum; i++ ) { phi = AIR_AFFINE( 1, i, vertNum, 0, 2*AIR_PI ); ELL_4V_SET( pld->xyzw + 4*i, airSgnPow( cos( phi ), alpha ), airSgnPow( sin( phi ), alpha ), 0.0, 1.0 ); /* printf( "!%s: xyzw[%u] = %g %g %g %g\n", me, i , ( pld->xyzw + 4*i )[0], ( pld->xyzw + 4*i )[1], ( pld->xyzw + 4*i )[2], ( pld->xyzw + 4*i )[3] ); */ } if ( ( 1 << limnPolyDataInfoNorm ) & infoBitFlag ) { for ( i=0; i<vertNum; i++ ) { ELL_3V_SET( pld->norm + 3*i, 0.0, 0.0, 1.0 ); } } if ( ( 1 << limnPolyDataInfoRGBA ) & infoBitFlag ) { for ( i=0; i<vertNum; i++ ) { ELL_4V_SET( pld->rgba + 4*i, 255, 255, 255, 255 ); } } if ( ( 1 << limnPolyDataInfoTex2 ) & infoBitFlag ) { /* punting */ ELL_2V_COPY( pld->tex2 + 2*i, pld->xyzw + 4*i ); } if ( ( 1 << limnPolyDataInfoTang ) & infoBitFlag ) { /* punting */ ELL_3V_SET( pld->tang + 3*i, 0.0, 0.0, 0.0 ); } pld->type[0] = limnPrimitiveTriangleFan; for ( i=0; i<vertNum; i++ ) { pld->indx[i] = i; /* printf( "!%s: idx[%u] = %u\n", me, i, pld->indx[i] ); */ } /* very last index loops around to first non-origin point */ pld->indx[i] = 1; /* printf( "!%s: idx[%u] = %u\n", me, i, pld->indx[i] ); */ pld->icnt[0] = vertNum+1; return 0; }

/Users/scm/git/github/teem/src/limn/qn.c

/Users/scm/git/github/teem/src/limn/renderLimn.c

/Users/scm/git/github/teem/src/limn/shapes.c

/Users/scm/git/github/teem/src/limn/splineEval.c

/Users/scm/git/github/teem/src/limn/splineMethods.c

/Users/scm/git/github/teem/src/limn/splineMisc.c

/Users/scm/git/github/teem/src/limn/test/clip.c

/Users/scm/git/github/teem/src/limn/test/intx.c

/Users/scm/git/github/teem/src/limn/test/light.c

/Users/scm/git/github/teem/src/limn/test/lpu.c

/Users/scm/git/github/teem/src/limn/test/map.c

/Users/scm/git/github/teem/src/limn/test/off2eps.c

/Users/scm/git/github/teem/src/limn/test/plot.c

/Users/scm/git/github/teem/src/limn/test/soid.c

/Users/scm/git/github/teem/src/limn/test/tbc.c

/Users/scm/git/github/teem/src/limn/test/tcam.c

/Users/scm/git/github/teem/src/limn/test/tcamanim.c

/Users/scm/git/github/teem/src/limn/test/tio.c

/Users/scm/git/github/teem/src/limn/test/tps.c

/Users/scm/git/github/teem/src/limn/test/tqn.c

/Users/scm/git/github/teem/src/limn/test/triimg.c

/Users/scm/git/github/teem/src/limn/test/tspline.c

/Users/scm/git/github/teem/src/limn/transform.c

/Users/scm/git/github/teem/src/matlab/nrrdLoad.c

/Users/scm/git/github/teem/src/matlab/nrrdLoadOrientation.c

/Users/scm/git/github/teem/src/matlab/nrrdSave.c

/Users/scm/git/github/teem/src/meet/enumall.c

/Users/scm/git/github/teem/src/meet/meetGage.c

/Users/scm/git/github/teem/src/meet/meetNrrd.c

/Users/scm/git/github/teem/src/meet/meetPull.c

/Users/scm/git/github/teem/src/meet/test/strace.c

/Users/scm/git/github/teem/src/meet/test/tenums.c

/Users/scm/git/github/teem/src/meet/test/vpnts.c

/Users/scm/git/github/teem/src/mite/defaultsMite.c

/Users/scm/git/github/teem/src/mite/kindnot.c

/Users/scm/git/github/teem/src/mite/ray.c

/Users/scm/git/github/teem/src/mite/renderMite.c

/Users/scm/git/github/teem/src/mite/shade.c

/Users/scm/git/github/teem/src/mite/thread.c

/Users/scm/git/github/teem/src/mite/txf.c

/Users/scm/git/github/teem/src/mite/user.c

/Users/scm/git/github/teem/src/moss/defaultsMoss.c

/Users/scm/git/github/teem/src/moss/hestMoss.c

/Users/scm/git/github/teem/src/moss/methodsMoss.c

/Users/scm/git/github/teem/src/moss/sampler.c

/Users/scm/git/github/teem/src/moss/test/invert.c

/Users/scm/git/github/teem/src/moss/xform.c

/Users/scm/git/github/teem/src/nrrd/accessors.c

/Users/scm/git/github/teem/src/nrrd/apply1D.c

/Users/scm/git/github/teem/src/nrrd/apply2D.c

/Users/scm/git/github/teem/src/nrrd/arith.c

/Users/scm/git/github/teem/src/nrrd/arraysNrrd.c

/Users/scm/git/github/teem/src/nrrd/axis.c

/Users/scm/git/github/teem/src/nrrd/bsplKernel.c

/Users/scm/git/github/teem/src/nrrd/cc.c

/Users/scm/git/github/teem/src/nrrd/ccmethods.c

/Users/scm/git/github/teem/src/nrrd/comment.c

/Users/scm/git/github/teem/src/nrrd/convertNrrd.c

/Users/scm/git/github/teem/src/nrrd/defaultsNrrd.c

/Users/scm/git/github/teem/src/nrrd/deringNrrd.c

/Users/scm/git/github/teem/src/nrrd/encoding.c

/Users/scm/git/github/teem/src/nrrd/encodingAscii.c

/Users/scm/git/github/teem/src/nrrd/encodingBzip2.c

/Users/scm/git/github/teem/src/nrrd/encodingGzip.c

/Users/scm/git/github/teem/src/nrrd/encodingHex.c

/Users/scm/git/github/teem/src/nrrd/encodingRaw.c

/Users/scm/git/github/teem/src/nrrd/encodingZRL.c

/Users/scm/git/github/teem/src/nrrd/endianNrrd.c

/Users/scm/git/github/teem/src/nrrd/enumsNrrd.c

/Users/scm/git/github/teem/src/nrrd/fftNrrd.c

/Users/scm/git/github/teem/src/nrrd/filt.c

/Users/scm/git/github/teem/src/nrrd/format.c

/Users/scm/git/github/teem/src/nrrd/formatEPS.c

/Users/scm/git/github/teem/src/nrrd/formatNRRD.c

/Users/scm/git/github/teem/src/nrrd/formatPNG.c

/Users/scm/git/github/teem/src/nrrd/formatPNM.c

/Users/scm/git/github/teem/src/nrrd/formatText.c

/Users/scm/git/github/teem/src/nrrd/formatVTK.c

/Users/scm/git/github/teem/src/nrrd/gzio.c

/Users/scm/git/github/teem/src/nrrd/hestNrrd.c

/Users/scm/git/github/teem/src/nrrd/histogram.c

/Users/scm/git/github/teem/src/nrrd/iter.c

/Users/scm/git/github/teem/src/nrrd/kernel.c

/Users/scm/git/github/teem/src/nrrd/keyvalue.c

/Users/scm/git/github/teem/src/nrrd/map.c

/Users/scm/git/github/teem/src/nrrd/measure.c

/* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2013, 2012, 2011, 2010, 2009 University of Chicago Copyright ( C ) 2008, 2007, 2006, 2005 Gordon Kindlmann Copyright ( C ) 2004, 2003, 2002, 2001, 2000, 1999, 1998 University of Utah This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "nrrd.h" #include "privateNrrd.h" /* the non-histogram measures assume that there will be no NaNs in data */ void 29 _nrrdMeasureUnknown( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { static const char me[]="_nrrdMeasureUnknown"; AIR_UNUSED( line ); AIR_UNUSED( lineType ); AIR_UNUSED( len ); AIR_UNUSED( axmin ); AIR_UNUSED( axmax ); fprintf( stderr, "%s: Need To Specify A Measure !!! \n", me ); nrrdDStore[ansType]( ans, AIR_NAN ); } void 44 _nrrdMeasureMin( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, M, ( *lup )( const void*, size_t ); size_t ii; AIR_UNUSED( axmin ); AIR_UNUSED( axmax ); lup = nrrdDLookup[lineType]; if ( nrrdTypeIsIntegral[lineType] ) { M = lup( line, 0 ); for ( ii=1; ii<len; ii++ ) { val = lup( line, ii ); M = AIR_MIN( M, val ); } } else { M = AIR_NAN; for ( ii=0; !AIR_EXISTS( M ) && ii<len; ii++ ) { M = lup( line, ii ); } for ( ; ii<len; ii++ ) { val = lup( line, ii ); if ( AIR_EXISTS( val ) ) { M = AIR_MIN( M, val ); } } } nrrdDStore[ansType]( ans, M ); } void 76 _nrrdMeasureMax( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, M, ( *lup )( const void*, size_t ); size_t ii; AIR_UNUSED( axmin ); AIR_UNUSED( axmax ); lup = nrrdDLookup[lineType]; if ( nrrdTypeIsIntegral[lineType] ) { M = lup( line, 0 ); for ( ii=1; ii<len; ii++ ) { val = lup( line, ii ); M = AIR_MAX( M, val ); } } else { M = AIR_NAN; for ( ii=0; !AIR_EXISTS( M ) && ii<len; ii++ ) { M = lup( line, ii ); } for ( ; ii<len; ii++ ) { val = lup( line, ii ); if ( AIR_EXISTS( val ) ) { M = AIR_MAX( M, val ); } } } nrrdDStore[ansType]( ans, M ); } void 107 _nrrdMeasureProduct( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, P, ( *lup )( const void*, size_t ); size_t ii; AIR_UNUSED( axmin ); AIR_UNUSED( axmax ); lup = nrrdDLookup[lineType]; if ( nrrdTypeIsIntegral[lineType] ) { P = 1.0; for ( ii=0; ii<len; ii++ ) { P *= lup( line, ii ); } } else { P = AIR_NAN; /* the point of this is to ensure that that if there are NO existent values, then the return is NaN */ for ( ii=0; !AIR_EXISTS( P ) && ii<len; ii++ ) { P = lup( line, ii ); } for ( ; ii<len; ii++ ) { val = lup( line, ii ); if ( AIR_EXISTS( val ) ) { P *= val; } } } nrrdDStore[ansType]( ans, P ); } void 139 _nrrdMeasureSum( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, S, ( *lup )( const void*, size_t ); size_t ii; AIR_UNUSED( axmin ); AIR_UNUSED( axmax ); lup = nrrdDLookup[lineType]; if ( nrrdTypeIsIntegral[lineType] ) { S = 0.0; for ( ii=0; ii<len; ii++ ) { S += lup( line, ii ); } } else { S = AIR_NAN; for ( ii=0; !AIR_EXISTS( S ) && ii<len; ii++ ) S = lup( line, ii ); for ( ; ii<len; ii++ ) { val = lup( line, ii ); if ( AIR_EXISTS( val ) ) { S += val; } } } nrrdDStore[ansType]( ans, S ); } void 168 _nrrdMeasureMean( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, S, M, ( *lup )( const void*, size_t ); size_t ii, count; AIR_UNUSED( axmin ); AIR_UNUSED( axmax ); lup = nrrdDLookup[lineType]; if ( nrrdTypeIsIntegral[lineType] ) { S = 0.0; for ( ii=0; ii<len; ii++ ) { S += lup( line, ii ); } M = S/len; } else { S = AIR_NAN; for ( ii=0; !AIR_EXISTS( S ) && ii<len; ii++ ) { S = lup( line, ii ); } if ( AIR_EXISTS( S ) ) { /* there was an existent value */ count = 1; for ( ; ii<len; ii++ ) { val = lup( line, ii ); if ( AIR_EXISTS( val ) ) { count++; S += val; } } M = S/count; } else { /* there were NO existent values */ M = AIR_NAN; } } nrrdDStore[ansType]( ans, M ); } /* stupid little forward declaration */ void 209 _nrrdMeasureHistoMode( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ); void 214 _nrrdMeasureMode( void *ans, int ansType, const void *_line, int lineType, size_t len, double axmin, double axmax ) { Nrrd *nline, *nhist; void *line; AIR_UNUSED( axmin ); AIR_UNUSED( axmax ); line = calloc( len, nrrdTypeSize[lineType] ); if ( line ) { memcpy( line, _line, len*nrrdTypeSize[lineType] ); nline = nrrdNew( ); if ( nrrdWrap_va( nline, line, lineType, 1, len ) ) { free( biffGetDone( NRRD ) ); nrrdNix( nline ); nrrdDStore[ansType]( ans, AIR_NAN ); return; } nhist = nrrdNew( ); if ( nrrdHisto( nhist, nline, NULL, NULL, nrrdStateMeasureModeBins, nrrdTypeInt ) ) { free( biffGetDone( NRRD ) ); nrrdNuke( nhist ); nrrdNix( nline ); nrrdDStore[ansType]( ans, AIR_NAN ); return; } /* now we pass this histogram off to histo-mode */ _nrrdMeasureHistoMode( ans, ansType, nhist->data, nrrdTypeInt, nrrdStateMeasureModeBins, nhist->axis[0].min, nhist->axis[0].max ); nrrdNuke( nhist ); nrrdNix( nline ); } else { nrrdDStore[ansType]( ans, 0 ); } return; } void 256 _nrrdMeasureMedian( void *ans, int ansType, const void *_line, int lineType, size_t len, double axmin, double axmax ) { double M=0, ( *lup )( const void*, size_t ); size_t ii, mid; void *line; AIR_UNUSED( axmin ); AIR_UNUSED( axmax ); lup = nrrdDLookup[lineType]; line = calloc( len, nrrdTypeSize[lineType] ); if ( line ) { memcpy( line, _line, len*nrrdTypeSize[lineType] ); /* yes, I know, this is not the fastest median. I'll get to it ... */ qsort( line, len, nrrdTypeSize[lineType], nrrdValCompare[lineType] ); M = AIR_NAN; for ( ii=0; !AIR_EXISTS( M ) && ii<len; ii++ ) { M = lup( line, ii ); } if ( AIR_EXISTS( M ) ) { /* i is index AFTER first existent value */ ii--; len -= ii; mid = len/2; if ( len % 2 ) { /* len is odd, there is a middle value, its at mid */ M = lup( line, ii+mid ); } else { /* len is even, two middle values are at mid-1 and mid */ M = ( lup( line, ii+mid-1 ) + lup( line, ii+mid ) )/2; } } } nrrdDStore[ansType]( ans, M ); } void 295 _nrrdMeasureL1( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, S, ( *lup )( const void*, size_t ); size_t ii; AIR_UNUSED( axmin ); AIR_UNUSED( axmax ); lup = nrrdDLookup[lineType]; if ( nrrdTypeIsIntegral[lineType] ) { S = 0.0; for ( ii=0; ii<len; ii++ ) { val = lup( line, ii ); S += AIR_ABS( val ); } } else { S = AIR_NAN; for ( ii=0; !AIR_EXISTS( S ) && ii<len; ii++ ) { S = lup( line, ii ); } S = AIR_ABS( S ); for ( ; ii<len; ii++ ) { val = lup( line, ii ); if ( AIR_EXISTS( val ) ) { S += AIR_ABS( val ); } } } nrrdDStore[ansType]( ans, S ); } #define L2_BODY( FOUR ) \ 327 AIR_UNUSED( axmin ); \ 328 AIR_UNUSED( axmax ); \ lup = nrrdDLookup[lineType]; \ if ( nrrdTypeIsIntegral[lineType] ) { \ S = 0.0; \ count = len; \ for ( ii=0; ii<len; ii++ ) { \ val = lup( line, ii ); \ S += ( FOUR ) ? val*val*val*val : val*val; \ } \ } else { \ S = AIR_NAN; \ count = 0; \ for ( ii=0; !AIR_EXISTS( S ) && ii<len; ii++ ) { \ S = lup( line, ii ); \ } \ if ( AIR_EXISTS( S ) ) { \ /* there's at least one existing value */ \ count = 1; \ S *= ( FOUR ) ? S*S*S : S ; \ for ( ; ii<len; ii++ ) { \ val = lup( line, ii ); \ if ( AIR_EXISTS( val ) ) { \ count++; \ S += ( FOUR ) ? val*val*val*val : val*val; \ } \ } \ } \ } void _nrrdMeasureL2( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, S, aa, ( *lup )( const void*, size_t ); size_t ii, count; L2_BODY( AIR_FALSE ); if ( AIR_EXISTS( S ) ) { aa = sqrt( S ); } else { aa = AIR_NAN; } nrrdDStore[ansType]( ans, aa ); } void _nrrdMeasureL4( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, S, aa, ( *lup )( const void*, size_t ); size_t ii, count; L2_BODY( AIR_TRUE ); if ( AIR_EXISTS( S ) ) { aa = sqrt( sqrt( S ) ); } else { aa = AIR_NAN; } nrrdDStore[ansType]( ans, aa ); } void _nrrdMeasureNormalizedL2( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, S, aa, ( *lup )( const void*, size_t ); size_t ii, count; L2_BODY( AIR_FALSE ); if ( AIR_EXISTS( S ) ) { aa = sqrt( S )/count; } else { aa = AIR_NAN; } nrrdDStore[ansType]( ans, aa ); } void _nrrdMeasureRootMeanSquare( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, S, aa, ( *lup )( const void*, size_t ); size_t ii, count; L2_BODY( AIR_FALSE ); if ( AIR_EXISTS( S ) ) { aa = sqrt( S/count ); } else { aa = AIR_NAN; } nrrdDStore[ansType]( ans, aa ); } void _nrrdMeasureLinf( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, M, ( *lup )( const void*, size_t ); size_t ii; AIR_UNUSED( axmin ); AIR_UNUSED( axmax ); lup = nrrdDLookup[lineType]; if ( nrrdTypeIsIntegral[lineType] ) { val = lup( line, 0 ); M = AIR_ABS( val ); for ( ii=1; ii<len; ii++ ) { val = lup( line, ii ); val = AIR_ABS( val ); M = AIR_MAX( M, val ); } } else { M = AIR_NAN; for ( ii=0; !AIR_EXISTS( M ) && ii<len; ii++ ) { M = lup( line, ii ); } M = AIR_ABS( M ); for ( ; ii<len; ii++ ) { val = lup( line, ii ); if ( AIR_EXISTS( val ) ) { val = AIR_ABS( val ); M = AIR_MAX( M, val ); } } } nrrdDStore[ansType]( ans, M ); } /* ========================================================== */ #if 0 /* two variance functions: 0 for new two-pass ( more accurate ) 1 for old single-pass */ void _nrrdMeasureVariance( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, S, SS, ( *lup )( const void*, size_t ); size_t ii, count; AIR_UNUSED( axmin ); AIR_UNUSED( axmax ); SS = S = 0.0; lup = nrrdDLookup[lineType]; if ( nrrdTypeIsIntegral[lineType] ) { for ( ii=0; ii<len; ii++ ) { val = lup( line, ii ); S += val; SS += val*val; } S /= len; SS /= len; } else { count = 0; for ( ii=0; ii<len; ii++ ) { val = lup( line, ii ); if ( AIR_EXISTS( val ) ) { count++; S += val; SS += val*val; } } if ( count ) { S /= count; SS /= count; } else { S = SS = AIR_NAN; } } /* HEY: the AIR_MAX is needed because precision errors can produce a negative value for SS - S*S; this may be a sign of the false economy of doing the variance calculation in a single pass */ nrrdDStore[ansType]( ans, AIR_MAX( 0.0, SS - S*S ) ); } #else /* ========================================================== */ void _nrrdMeasureVariance( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double vari, mean, val, ( *lup )( const void*, size_t ); size_t ii, count; AIR_UNUSED( axmin ); AIR_UNUSED( axmax ); mean = vari = 0.0; lup = nrrdDLookup[lineType]; if ( nrrdTypeIsIntegral[lineType] ) { for ( ii=0; ii<len; ii++ ) { mean += lup( line, ii ); } mean /= len; for ( ii=0; ii<len; ii++ ) { val = lup( line, ii ); vari += ( val-mean )*( val-mean ); } vari /= len; } else { count = 0; for ( ii=0; ii<len; ii++ ) { val = lup( line, ii ); if ( AIR_EXISTS( val ) ) { count++; mean += val; } } if ( count ) { mean /= count; for ( ii=0; ii<len; ii++ ) { val = lup( line, ii ); if ( AIR_EXISTS( val ) ) { vari += ( val-mean )*( val-mean ); } } vari /= count; } else { vari = AIR_NAN; } } nrrdDStore[ansType]( ans, vari ); } #endif /* ========================================================== */ void _nrrdMeasureSD( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double var; _nrrdMeasureVariance( ans, ansType, line, lineType, len, axmin, axmax ); var = nrrdDLoad[ansType]( ans ); nrrdDStore[ansType]( ans, sqrt( var ) ); } void _nrrdMeasureCoV( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, S, M, ( *lup )( const void*, size_t ), diff, stdv; size_t ii, count; AIR_UNUSED( axmin ); AIR_UNUSED( axmax ); lup = nrrdDLookup[lineType]; if ( nrrdTypeIsIntegral[lineType] ) { S = 0.0; for ( ii=0; ii<len; ii++ ) { S += lup( line, ii ); } M = S/len; diff = 0.0; for ( ii=0; ii<len; ii++ ) { val = lup( line, ii ); diff += ( M-val )*( M-val ); } stdv = sqrt( diff/len ); } else { S = AIR_NAN; for ( ii=0; !AIR_EXISTS( S ) && ii<len; ii++ ) { S = lup( line, ii ); } if ( AIR_EXISTS( S ) ) { /* there was an existent value */ count = 1; for ( ; ii<len; ii++ ) { val = lup( line, ii ); if ( AIR_EXISTS( val ) ) { count++; S += val; } } M = S/count; diff = 0.0; for ( ii=0; ii<len; ii++ ) { val = lup( line, ii ); if ( AIR_EXISTS( val ) ) { diff += ( M-val )*( M-val ); } } stdv = sqrt( diff/count ); } else { /* there were NO existent values */ M = stdv = AIR_NAN; } } nrrdDStore[ansType]( ans, stdv/M ); } void _nrrdMeasureLineFit( double *intc, double *slope, const void *line, int lineType, size_t len, double axmin, double axmax ) { double x, y, xi=0, yi=0, xiyi=0, xisq=0, det, ( *lup )( const void*, size_t ); size_t ii; lup = nrrdDLookup[lineType]; if ( !( AIR_EXISTS( axmin ) && AIR_EXISTS( axmax ) ) ) { axmin = 0; axmax = AIR_CAST( double, len-1 ); } if ( 1 == len ) { *slope = 0; *intc = lup( line, 0 ); } else { for ( ii=0; ii<len; ii++ ) { x = NRRD_NODE_POS( axmin, axmax, len, ii ); y = lup( line, ii ); xi += x; yi += y; xiyi += x*y; xisq += x*x; } det = len*xisq - xi*xi; *slope = ( len*xiyi - xi*yi )/det; *intc = ( -xi*xiyi + xisq*yi )/det; } } void _nrrdMeasureLineSlope( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double slope, intc; _nrrdMeasureLineFit( &intc, &slope, line, lineType, len, axmin, axmax ); nrrdDStore[ansType]( ans, slope ); } void _nrrdMeasureLineIntercept( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double slope, intc; _nrrdMeasureLineFit( &intc, &slope, line, lineType, len, axmin, axmax ); nrrdDStore[ansType]( ans, intc ); } void _nrrdMeasureLineError( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double x, y, slope, intc, tmp, err=0, ( *lup )( const void*, size_t ); size_t ii; _nrrdMeasureLineFit( &intc, &slope, line, lineType, len, axmin, axmax ); if ( !( AIR_EXISTS( axmin ) && AIR_EXISTS( axmax ) ) ) { axmin = 0; axmax = AIR_CAST( double, len-1 ); } lup = nrrdDLookup[lineType]; for ( ii=0; ii<len; ii++ ) { x = NRRD_NODE_POS( axmin, axmax, len, ii ); y = lup( line, ii ); tmp = slope*x + intc - y; err += tmp*tmp; } nrrdDStore[ansType]( ans, err ); } void _nrrdMeasureSkew( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, diff, mean, vari, third, ( *lup )( const void*, size_t ); size_t ii, count; AIR_UNUSED( axmin ); AIR_UNUSED( axmax ); /* we don't try to do any one-pass short-cuts */ /* find the mean */ mean = 0; lup = nrrdDLookup[lineType]; if ( nrrdTypeIsIntegral[lineType] ) { count = len; for ( ii=0; ii<len; ii++ ) { val = lup( line, ii ); mean += val; } } else { count = 0; for ( ii=0; ii<len; ii++ ) { val = lup( line, ii ); if ( AIR_EXISTS( val ) ) { count++; mean += val; } } } if ( 0 == count ) { nrrdDStore[ansType]( ans, AIR_NAN ); return; } mean /= count; /* find the variance and third moment */ vari = third = 0; if ( nrrdTypeIsIntegral[lineType] ) { for ( ii=0; ii<len; ii++ ) { diff = lup( line, ii ) - mean; vari += diff*diff; third += diff*diff*diff; } } else { for ( ii=0; ii<len; ii++ ) { val = lup( line, ii ); if ( AIR_EXISTS( val ) ) { diff = val - mean; vari += diff*diff; third += diff*diff*diff; } } } if ( 0 == vari ) { /* why not have an existent value ... */ nrrdDStore[ansType]( ans, 0 ); return; } vari /= count; third /= count; nrrdDStore[ansType]( ans, third/( vari*sqrt( vari ) ) ); } /* ** one thing which ALL the _nrrdMeasureHisto measures assume is that, ** being a histogram, the input array will not have any non-existent ** values. It can be floating point, because it is plausible to have ** some histogram composed of fractionally weighted hits, but there is ** no way that it is reasonable to have NaN in a bin, and it is extremely ** unlikely that Inf could actually be created in a floating point ** histogram. ** ** Values in the histogram can be positive or negative, but negative ** values are always ignored. ** ** All the the _nrrdMeasureHisto measures assume that if not both ** axmin and axmax are existent, then ( axmin, axmax ) = ( -0.5, len-0.5 ). ** Exercise for the reader: Show that ** ** i == NRRD_POS( nrrdCenterCell, 0, len-1, len, i ) ** ** This justifies that fact that when axmin and axmax are not both ** existent, then we can simply calculate the answer in index space, ** and not have to do any shifting or scaling at the end to account ** for the fact that we assume ( axmin, axmax ) = ( -0.5, len-0.5 ). */ void _nrrdMeasureHistoMedian( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double sum, tmp, half, ansD, ( *lup )( const void*, size_t ); size_t ii; lup = nrrdDLookup[lineType]; sum = 0; for ( ii=0; ii<len; ii++ ) { tmp = lup( line, ii ); sum += ( tmp > 0 ? tmp : 0 ); } if ( !sum ) { nrrdDStore[ansType]( ans, AIR_NAN ); return; } /* else there was something in the histogram */ half = sum/2; sum = 0; for ( ii=0; ii<len; ii++ ) { tmp = lup( line, ii ); sum += ( tmp > 0 ? tmp : 0 ); if ( sum >= half ) { break; } } ansD = AIR_CAST( double, ii ); if ( AIR_EXISTS( axmin ) && AIR_EXISTS( axmax ) ) { ansD = NRRD_CELL_POS( axmin, axmax, len, ansD ); } nrrdDStore[ansType]( ans, ansD ); } void _nrrdMeasureHistoMode( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, max, idxsum, ansD, ( *lup )( const void*, size_t ); size_t ii, idxcount; lup = nrrdDLookup[lineType]; max = -DBL_MAX; for ( ii=0; ii<len; ii++ ) { val = lup( line, ii ); if ( AIR_EXISTS( val ) ) { max = AIR_MAX( max, val ); } } if ( -DBL_MAX == max ) { nrrdDStore[ansType]( ans, AIR_NAN ); return; } /* else there was something in the histogram */ /* we assume that there may be multiple bins which reach the maximum height, and we average all those indices. This may well be bone-headed, and is subject to change. 19 July 03: with the addition of the final "type" argument to nrrdProject, the bone-headedness has been alleviated somewhat, since you can pass nrrdTypeFloat or nrrdTypeDouble to get an accurate answer */ idxsum = 0; idxcount = 0; for ( ii=0; ii<len; ii++ ) { val = lup( line, ii ); if ( val == max ) { idxcount++; idxsum += ii; } } if ( max == 0 && len == idxcount ) { /* entire histogram was zeros => empty distribution => no mode */ nrrdDStore[ansType]( ans, AIR_NAN ); return; } ansD = idxsum/idxcount; /* printf( "idxsum = %g; idxcount = %d --> ansD = %g --> ", ( float )idxsum, idxcount, ansD ); */ if ( AIR_EXISTS( axmin ) && AIR_EXISTS( axmax ) ) { ansD = NRRD_CELL_POS( axmin, axmax, len, ansD ); } /* printf( "%g\n", ansD ); */ nrrdDStore[ansType]( ans, ansD ); } void _nrrdMeasureHistoMean( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double count, hits, ansD, ( *lup )( const void*, size_t ); size_t ii; lup = nrrdDLookup[lineType]; ansD = count = 0; for ( ii=0; ii<len; ii++ ) { hits = lup( line, ii ); hits = AIR_MAX( hits, 0 ); count += hits; ansD += hits*ii; } if ( !count ) { nrrdDStore[ansType]( ans, AIR_NAN ); return; } ansD /= count; if ( AIR_EXISTS( axmin ) && AIR_EXISTS( axmax ) ) { ansD = NRRD_CELL_POS( axmin, axmax, len, ansD ); } nrrdDStore[ansType]( ans, ansD ); } void _nrrdMeasureHistoVariance( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double S, SS, count, hits, val, ( *lup )( const void*, size_t ); size_t ii; lup = nrrdDLookup[lineType]; count = 0; SS = S = 0.0; /* we fix axmin, axmax now because GK is better safe than sorry */ if ( !( AIR_EXISTS( axmin ) && AIR_EXISTS( axmax ) ) ) { axmin = -0.5; axmax = len-0.5; } for ( ii=0; ii<len; ii++ ) { val = NRRD_CELL_POS( axmin, axmax, len, ii ); hits = lup( line, ii ); hits = AIR_MAX( hits, 0 ); count += hits; S += hits*val; SS += hits*val*val; } if ( !count ) { nrrdDStore[ansType]( ans, AIR_NAN ); return; } S /= count; SS /= count; /* HEY: the AIR_MAX is needed because precision errors can produce a negative value for SS - S*S; this may be a sign of the false economy of doing the variance calculation in a single pass */ nrrdDStore[ansType]( ans, AIR_MAX( 0.0, SS - S*S ) ); } void _nrrdMeasureHistoSD( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double var; _nrrdMeasureHistoVariance( ans, ansType, line, lineType, len, axmin, axmax ); var = nrrdDLoad[ansType]( ans ); nrrdDStore[ansType]( ans, sqrt( var ) ); } void _nrrdMeasureHistoProduct( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, product, count, hits, ( *lup )( const void*, size_t ); size_t ii; if ( !( AIR_EXISTS( axmin ) && AIR_EXISTS( axmax ) ) ) { axmin = -0.5; axmax = len-0.5; } lup = nrrdDLookup[lineType]; product = 1.0; count = 0; for ( ii=0; ii<len; ii++ ) { val = NRRD_CELL_POS( axmin, axmax, len, ii ); hits = lup( line, ii ); hits = AIR_MAX( hits, 0 ); count += hits; product *= pow( val, hits ); } if ( !count ) { nrrdDStore[ansType]( ans, AIR_NAN ); return; } nrrdDStore[ansType]( ans, product ); } void _nrrdMeasureHistoSum( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double sum, hits, val, ( *lup )( const void*, size_t ); size_t ii; if ( !( AIR_EXISTS( axmin ) && AIR_EXISTS( axmax ) ) ) { axmin = -0.5; axmax = len-0.5; } lup = nrrdDLookup[lineType]; sum = 0; for ( ii=0; ii<len; ii++ ) { val = NRRD_CELL_POS( axmin, axmax, len, ii ); hits = lup( line, ii ); hits = AIR_MAX( hits, 0 ); sum += hits*val; } nrrdDStore[ansType]( ans, sum ); } void _nrrdMeasureHistoL2( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double l2, count, hits, val, ( *lup )( const void*, size_t ); size_t ii; if ( !( AIR_EXISTS( axmin ) && AIR_EXISTS( axmax ) ) ) { axmin = -0.5; axmax = len-0.5; } lup = nrrdDLookup[lineType]; l2 = count = 0; for ( ii=0; ii<len; ii++ ) { val = NRRD_CELL_POS( axmin, axmax, len, ii ); hits = lup( line, ii ); hits = AIR_MAX( hits, 0 ); count += hits; l2 += hits*val*val; } if ( !count ) { nrrdDStore[ansType]( ans, AIR_NAN ); return; } nrrdDStore[ansType]( ans, l2 ); } void _nrrdMeasureHistoMax( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, ( *lup )( const void*, size_t ); size_t ii; if ( !( AIR_EXISTS( axmin ) && AIR_EXISTS( axmax ) ) ) { axmin = -0.5; axmax = len-0.5; } lup = nrrdDLookup[lineType]; /* we're using ii-1 as index to avoid wrap-around with size_t index */ for ( ii=len; ii>0; ii-- ) { if ( lup( line, ii-1 ) > 0 ) { break; } } if ( ii==0 ) { nrrdDStore[ansType]( ans, AIR_NAN ); return; } val = NRRD_CELL_POS( axmin, axmax, len, ii-1 ); nrrdDStore[ansType]( ans, val ); } void _nrrdMeasureHistoMin( void *ans, int ansType, const void *line, int lineType, size_t len, double axmin, double axmax ) { double val, ( *lup )( const void*, size_t ); size_t ii; if ( !( AIR_EXISTS( axmin ) && AIR_EXISTS( axmax ) ) ) { axmin = -0.5; axmax = len-0.5; } lup = nrrdDLookup[lineType]; for ( ii=0; ii<len; ii++ ) { if ( lup( line, ii ) > 0 ) { break; } } if ( ii==len ) { nrrdDStore[ansType]( ans, AIR_NAN ); return; } val = NRRD_CELL_POS( axmin, axmax, len, ii ); nrrdDStore[ansType]( ans, val ); } void ( * nrrdMeasureLine[NRRD_MEASURE_MAX+1] )( void *, int, const void *, int, size_t, double, double ) = { _nrrdMeasureUnknown, _nrrdMeasureMin, _nrrdMeasureMax, _nrrdMeasureMean, _nrrdMeasureMedian, _nrrdMeasureMode, _nrrdMeasureProduct, _nrrdMeasureSum, _nrrdMeasureL1, _nrrdMeasureL2, _nrrdMeasureL4, _nrrdMeasureNormalizedL2, _nrrdMeasureRootMeanSquare, _nrrdMeasureLinf, _nrrdMeasureVariance, _nrrdMeasureSD, _nrrdMeasureCoV, _nrrdMeasureSkew, _nrrdMeasureLineSlope, _nrrdMeasureLineIntercept, _nrrdMeasureLineError, _nrrdMeasureHistoMin, _nrrdMeasureHistoMax, _nrrdMeasureHistoMean, _nrrdMeasureHistoMedian, _nrrdMeasureHistoMode, _nrrdMeasureHistoProduct, _nrrdMeasureHistoSum, _nrrdMeasureHistoL2, _nrrdMeasureHistoVariance, _nrrdMeasureHistoSD }; int _nrrdMeasureType( const Nrrd *nin, int measr ) { static const char me[]="_nrrdMeasureType"; int type=nrrdTypeUnknown; switch( measr ) { case nrrdMeasureMin: case nrrdMeasureMax: case nrrdMeasureMedian: case nrrdMeasureMode: type = nin->type; break; case nrrdMeasureMean: /* the rational for this is that if you're after the average value along a scanline, you probably want it in the same format as what you started with, and if you really want an exact answer than you can always use nrrdMeasureSum and then divide. This may well be bone-headed, so is subject to change */ type = nin->type; break; case nrrdMeasureProduct: case nrrdMeasureSum: case nrrdMeasureL1: case nrrdMeasureL2: case nrrdMeasureL4: case nrrdMeasureNormalizedL2: case nrrdMeasureRootMeanSquare: case nrrdMeasureLinf: case nrrdMeasureVariance: case nrrdMeasureSD: case nrrdMeasureCoV: case nrrdMeasureSkew: case nrrdMeasureLineSlope: case nrrdMeasureLineIntercept: case nrrdMeasureLineError: type = nrrdStateMeasureType; break; case nrrdMeasureHistoMin: case nrrdMeasureHistoMax: case nrrdMeasureHistoProduct: case nrrdMeasureHistoSum: case nrrdMeasureHistoL2: case nrrdMeasureHistoMean: case nrrdMeasureHistoMedian: case nrrdMeasureHistoMode: case nrrdMeasureHistoVariance: case nrrdMeasureHistoSD: /* We ( currently ) don't keep track of the type of the original values which generated the histogram, and we may not even have access to that information. So we end up choosing one type for all these histogram-based measures */ type = nrrdStateMeasureHistoType; break; default: fprintf( stderr, "%s: PANIC: measr %d not handled\n", me, measr ); exit( 1 ); } return type; } int nrrdProject( Nrrd *nout, const Nrrd *cnin, unsigned int axis, int measr, int type ) { static const char me[]="nrrdProject", func[]="project"; int iType, oType, axmap[NRRD_DIM_MAX]; unsigned int ai, ei; size_t iElSz, oElSz, iSize[NRRD_DIM_MAX], oSize[NRRD_DIM_MAX], linLen, rowIdx, rowNum, colIdx, colNum, colStep; const char *ptr, *iData; char *oData, *line; double axmin, axmax; Nrrd *nin; airArray *mop; if ( !( cnin && nout ) ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( nout == cnin ) { biffAddf( NRRD, "%s: nout==nin disallowed", me ); return 1; } if ( nrrdTypeBlock == cnin->type ) { biffAddf( NRRD, "%s: can't project nrrd type %s", me, airEnumStr( nrrdType, nrrdTypeBlock ) ); return 1; } if ( !AIR_IN_OP( nrrdMeasureUnknown, measr, nrrdMeasureLast ) ) { biffAddf( NRRD, "%s: measure %d not recognized", me, measr ); return 1; } if ( 1 == cnin->dim ) { if ( 0 != axis ) { biffAddf( NRRD, "%s: axis must be 0, not %u, for 1-D array", me, axis ); return 1; } } else { if ( !( axis <= cnin->dim-1 ) ) { biffAddf( NRRD, "%s: axis %u not in range [0, %d]", me, axis, cnin->dim-1 ); return 1; } } if ( nrrdTypeDefault != type ) { if ( !( AIR_IN_OP( nrrdTypeUnknown, type, nrrdTypeLast ) ) ) { biffAddf( NRRD, "%s: got invalid target type %d", me, type ); return 1; } } mop = airMopNew( ); if ( 1 == cnin->dim ) { /* There are more efficient ways of dealing with this case; this way is easy to implement because it leaves most of the established code below only superficially changed; uniformly replacing nin with ( nin ? nin : cnin ), even if pointlessly so; this expression that can't be assigned to a new variable because of the difference in const. */ nin = nrrdNew( ); airMopAdd( mop, nin, ( airMopper )nrrdNuke, airMopAlways ); if ( nrrdAxesInsert( nin, cnin, 1 ) ) { biffAddf( NRRD, "%s: trouble inserting axis on 1-D array", me ); airMopError( mop ); return 1; } } else { nin = NULL; } iType = ( nin ? nin : cnin )->type; oType = ( nrrdTypeDefault != type ? type : _nrrdMeasureType( ( nin ? nin : cnin ), measr ) ); iElSz = nrrdTypeSize[iType]; oElSz = nrrdTypeSize[oType]; nrrdAxisInfoGet_nva( ( nin ? nin : cnin ), nrrdAxisInfoSize, iSize ); colNum = rowNum = 1; for ( ai=0; ai<( nin ? nin : cnin )->dim; ai++ ) { if ( ai < axis ) { colNum *= iSize[ai]; } else if ( ai > axis ) { rowNum *= iSize[ai]; } } linLen = iSize[axis]; colStep = linLen*colNum; for ( ai=0; ai<=( nin ? nin : cnin )->dim-2; ai++ ) { axmap[ai] = ai + ( ai >= axis ); } for ( ai=0; ai<=( nin ? nin : cnin )->dim-2; ai++ ) { oSize[ai] = iSize[axmap[ai]]; } if ( nrrdMaybeAlloc_nva( nout, oType, ( nin ? nin : cnin )->dim-1, oSize ) ) { biffAddf( NRRD, "%s: failed to create output", me ); airMopError( mop ); return 1; } /* allocate a scanline buffer */ if ( !( line = AIR_CALLOC( linLen*iElSz, char ) ) ) { char stmp1[AIR_STRLEN_SMALL], stmp2[AIR_STRLEN_SMALL]; biffAddf( NRRD, "%s: couldn't calloc( %s, %s ) scanline buffer", me, airSprintSize_t( stmp1, linLen ), airSprintSize_t( stmp2, iElSz ) ); airMopError( mop ); return 1; } airMopAdd( mop, line, airFree, airMopAlways ); /* the skinny */ axmin = ( nin ? nin : cnin )->axis[axis].min; axmax = ( nin ? nin : cnin )->axis[axis].max; iData = AIR_CAST( char *, ( nin ? nin : cnin )->data ); oData = AIR_CAST( char *, nout->data ); for ( rowIdx=0; rowIdx<rowNum; rowIdx++ ) { for ( colIdx=0; colIdx<colNum; colIdx++ ) { ptr = iData + iElSz*( colIdx + rowIdx*colStep ); for ( ei=0; ei<linLen; ei++ ) { memcpy( line + ei*iElSz, ptr + ei*iElSz*colNum, iElSz ); } nrrdMeasureLine[measr]( oData, oType, line, iType, linLen, axmin, axmax ); oData += oElSz; } } /* copy the peripheral information */ if ( nrrdAxisInfoCopy( nout, ( nin ? nin : cnin ), axmap, NRRD_AXIS_INFO_NONE ) ) { biffAddf( NRRD, "%s:", me ); airMopError( mop ); return 1; } if ( nrrdContentSet_va( nout, func, cnin /* hide possible axinsert */, "%d, %s", axis, airEnumStr( nrrdMeasure, measr ) ) ) { biffAddf( NRRD, "%s:", me ); airMopError( mop ); return 1; } /* this will copy the space origin over directly, which is reasonable */ if ( nrrdBasicInfoCopy( nout, ( nin ? nin : cnin ), NRRD_BASIC_INFO_DATA_BIT | NRRD_BASIC_INFO_TYPE_BIT | NRRD_BASIC_INFO_BLOCKSIZE_BIT | NRRD_BASIC_INFO_DIMENSION_BIT | NRRD_BASIC_INFO_CONTENT_BIT | NRRD_BASIC_INFO_COMMENTS_BIT | ( nrrdStateKeyValuePairsPropagate ? 0 : NRRD_BASIC_INFO_KEYVALUEPAIRS_BIT ) ) ) { biffAddf( NRRD, "%s:", me ); airMopError( mop ); return 1; } airMopOkay( mop ); return 0; }

/Users/scm/git/github/teem/src/nrrd/methodsNrrd.c

/* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2013, 2012, 2011, 2010, 2009 University of Chicago Copyright ( C ) 2008, 2007, 2006, 2005 Gordon Kindlmann Copyright ( C ) 2004, 2003, 2002, 2001, 2000, 1999, 1998 University of Utah This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "nrrd.h" #include "privateNrrd.h" /* Wed Sep 14 05:55:40 EDT 2005: these are no longer used void nrrdPeripheralInit( Nrrd *nrrd ) { nrrdBasicInfoInit( nrrd, NRRD_BASIC_INFO_DATA_BIT | NRRD_BASIC_INFO_TYPE_BIT | NRRD_BASIC_INFO_BLOCKSIZE_BIT | NRRD_BASIC_INFO_DIMENSION_BIT | NRRD_BASIC_INFO_CONTENT_BIT | NRRD_BASIC_INFO_COMMENTS_BIT | NRRD_BASIC_INFO_KEYVALUEPAIRS_BIT ); return; } int nrrdPeripheralCopy( Nrrd *nout, const Nrrd *nin ) { nrrdBasicInfoCopy( nout, nin, NRRD_BASIC_INFO_DATA_BIT | NRRD_BASIC_INFO_TYPE_BIT | NRRD_BASIC_INFO_BLOCKSIZE_BIT | NRRD_BASIC_INFO_DIMENSION_BIT | NRRD_BASIC_INFO_CONTENT_BIT | NRRD_BASIC_INFO_COMMENTS_BIT | NRRD_BASIC_INFO_KEYVALUEPAIRS_BIT ); return 0; } */ /* ---- BEGIN non-NrrdIO */ const int nrrdPresent = 42; /* ------------------------------------------------------------ */ NrrdBoundarySpec * 65 nrrdBoundarySpecNew( void ) { NrrdBoundarySpec *ret; ret = AIR_CALLOC( 1, NrrdBoundarySpec ); if ( ret ) { ret->boundary = nrrdBoundaryUnknown; ret->padValue = AIR_NAN; } return ret; } NrrdBoundarySpec * 77 nrrdBoundarySpecNix( NrrdBoundarySpec *bspec ) { return airFree( bspec ); } /* NOTE: this doesn't do a validity check! */ NrrdBoundarySpec * 84 nrrdBoundarySpecCopy( const NrrdBoundarySpec *bspec ) { NrrdBoundarySpec *ret; if ( bspec ) { ret = nrrdBoundarySpecNew( ); ret->boundary = bspec->boundary; ret->padValue = bspec->padValue; } else { ret = NULL; } return ret; } int 98 nrrdBoundarySpecCheck( const NrrdBoundarySpec *bspec ) { static const char me[]="nrrdBoundarySpecCheck"; if ( !bspec ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( airEnumValCheck( nrrdBoundary, bspec->boundary ) ) { biffAddf( NRRD, "%s: %d is not a valid %s value", me, bspec->boundary, nrrdBoundary->name ); return 1; } if ( nrrdBoundaryPad == bspec->boundary ) { if ( !AIR_EXISTS( bspec->padValue ) ) { biffAddf( NRRD, "%s: need existing pad value ( not %g ) with %s %s", me, bspec->padValue, nrrdBoundary->name, airEnumStr( nrrdBoundary, nrrdBoundaryPad ) ); return 1; } } return 0; } int 122 nrrdBoundarySpecParse( NrrdBoundarySpec *bspec, const char *_str ) { static const char me[]="nrrdBoundarySpecParse"; char *str, *parm; airArray *mop; if ( !( bspec && _str ) ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } str = airStrdup( _str ); if ( !str ) { biffAddf( NRRD, "%s: couldn't copy string", me ); return 1; } mop = airMopNew( ); airMopAdd( mop, str, airFree, airMopAlways ); parm = strchr( str, ':' ); if ( parm ) { *parm = '\0'; parm++; } bspec->boundary = airEnumVal( nrrdBoundary, str ); if ( nrrdBoundaryUnknown == bspec->boundary ) { biffAddf( NRRD, "%s: couldn't parse %s as a %s", me, str, nrrdBoundary->name ); airMopError( mop ); return 1; } if ( parm ) { if ( nrrdBoundaryPad != bspec->boundary ) { biffAddf( NRRD, "%s: can only have parms for %s ( not %s )", me, airEnumStr( nrrdBoundary, nrrdBoundaryPad ), airEnumStr( nrrdBoundary, bspec->boundary ) ); airMopError( mop ); return 1; } if ( 1 != sscanf( parm, "%lg", &( bspec->padValue ) ) ) { biffAddf( NRRD, "%s: couldn't parse \"%s\" as double", me, parm ); airMopError( mop ); return 1; } if ( !AIR_EXISTS( bspec->padValue ) ) { biffAddf( NRRD, "%s: need existant pad value ( not %g )", me, bspec->padValue ); airMopError( mop ); return 1; } } else { if ( nrrdBoundaryPad == bspec->boundary ) { biffAddf( NRRD, "%s: need padValue parm for %s", me, airEnumStr( nrrdBoundary, nrrdBoundaryPad ) ); airMopError( mop ); return 1; } bspec->padValue = AIR_NAN; } airMopOkay( mop ); return 0; } int 178 nrrdBoundarySpecSprint( char str[AIR_STRLEN_LARGE], const NrrdBoundarySpec *bspec ) { static const char me[]="nrrdBoundarySpecSprint"; char *out; if ( !( str && bspec ) ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( nrrdBoundarySpecCheck( bspec ) ) { biffAddf( NRRD, "%s: problem", me ); return 1; } out = str; sprintf( out, "%s", airEnumStr( nrrdBoundary, bspec->boundary ) ); out += strlen( out ); if ( nrrdBoundaryPad == bspec->boundary ) { sprintf( out, ":%.17g", bspec->padValue ); } return 0; } int 201 nrrdBoundarySpecCompare( const NrrdBoundarySpec *aa, const NrrdBoundarySpec *bb, int *differ, char explain[AIR_STRLEN_LARGE] ) { static const char me[]="nrrdBoundarySpecEqual"; if ( !differ ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( !!aa != !!bb ) { if ( explain ) { sprintf( explain, "NULL-ities differ: %s != %s", aa ? "non-NULL" : "NULL", bb ? "non-NULL" : "NULL" ); } *differ = 1; return 0; } if ( !aa ) { /* got two NULL boundary specs ==> equal */ *differ = 0; return 0; } if ( aa->boundary != bb->boundary ) { if ( explain ) { sprintf( explain, "boundaries differ: %s != %s", airEnumStr( nrrdBoundary, aa->boundary ), airEnumStr( nrrdBoundary, bb->boundary ) ); } *differ = 1; return 0; } if ( nrrdBoundaryPad == aa->boundary ) { if ( aa->padValue != bb->padValue ) { if ( explain ) { sprintf( explain, "padValue differ: %.17g != %.17g", aa->padValue, bb->padValue ); } *differ = 1; return 0; } } *differ = 0; return 0; } /* ---- END non-NrrdIO */ /* ------------------------------------------------------------ */ void 247 nrrdIoStateInit( NrrdIoState *nio ) { if ( nio ) { nio->path = ( char * )airFree( nio->path ); nio->base = ( char * )airFree( nio->base ); nio->line = ( char * )airFree( nio->line ); nio->dataFNFormat = ( char * )airFree( nio->dataFNFormat ); /* the way IO to/from strings works, I don't think this should be freed */ nio->headerStringRead = NULL; nio->headerStringWrite = NULL; airArrayLenSet( nio->dataFNArr, 0 ); airArrayLenSet( nio->dataFSkipArr, 0 ); /* closing this is always someone else's responsibility */ nio->headerFile = NULL; nio->dataFile = NULL; nio->dataFileDim = 0; nio->dataFNMin = 0; nio->dataFNMax = 0; nio->dataFNStep = 0; nio->dataFNIndex = 0; nio->lineLen = 0; nio->pos = 0; nio->endian = airEndianUnknown; nio->lineSkip = 0; nio->headerStrlen = 0; nio->headerStrpos = 0; nio->byteSkip = 0; memset( nio->seen, 0, ( NRRD_FIELD_MAX+1 )*sizeof( int ) ); nio->detachedHeader = AIR_FALSE; nio->bareText = nrrdDefaultWriteBareText; nio->charsPerLine = nrrdDefaultWriteCharsPerLine; nio->valsPerLine = nrrdDefaultWriteValsPerLine; nio->skipData = AIR_FALSE; nio->skipFormatURL = AIR_FALSE; nio->keepNrrdDataFileOpen = AIR_FALSE; nio->zlibLevel = -1; nio->zlibStrategy = nrrdZlibStrategyDefault; nio->bzip2BlockSize = -1; nio->learningHeaderStrlen = AIR_FALSE; nio->oldData = NULL; nio->oldDataSize = 0; nio->format = nrrdFormatUnknown; nio->encoding = nrrdEncodingUnknown; } return; } NrrdIoState * 295 nrrdIoStateNew( void ) { NrrdIoState *nio; nio = ( NrrdIoState * )calloc( 1, sizeof( NrrdIoState ) ); if ( nio ) { airPtrPtrUnion appu; nio->path = NULL; nio->base = NULL; nio->line = NULL; nio->dataFNFormat = NULL; nio->dataFN = NULL; nio->headerStringRead = NULL; nio->headerStringWrite = NULL; appu.cp = &( nio->dataFN ); nio->dataFNArr = airArrayNew( appu.v, NULL, sizeof( char * ), NRRD_FILENAME_INCR ); airArrayPointerCB( nio->dataFNArr, airNull, airFree ); nio->dataFSkip = NULL; appu.li = &( nio->dataFSkip ); nio->dataFSkipArr = airArrayNew( appu.v, NULL, sizeof( long int ), NRRD_FILENAME_INCR ); nio->format = nrrdFormatUnknown; nio->encoding = nrrdEncodingUnknown; nrrdIoStateInit( nio ); } return nio; } NrrdIoState * 325 nrrdIoStateNix( NrrdIoState *nio ) { nio->path = ( char * )airFree( nio->path ); nio->base = ( char * )airFree( nio->base ); nio->line = ( char * )airFree( nio->line ); nio->dataFNFormat = ( char * )airFree( nio->dataFNFormat ); nio->dataFNArr = airArrayNuke( nio->dataFNArr ); nio->dataFSkipArr = airArrayNuke( nio->dataFSkipArr ); /* the NrrdIoState never owned nio->oldData; we don't free it */ airFree( nio ); /* no NULL assignment, else compile warnings */ return NULL; } /* ---- BEGIN non-NrrdIO */ /* ------------------------------------------------------------ */ void 343 _nrrdResampleInfoInit( NrrdResampleInfo *info ) { int i, d; for ( d=0; d<NRRD_DIM_MAX; d++ ) { info->kernel[d] = NULL; info->samples[d] = 0; info->parm[d][0] = nrrdDefaultKernelParm0; for ( i=1; i<NRRD_KERNEL_PARMS_NUM; i++ ) info->parm[d][i] = AIR_NAN; info->min[d] = info->max[d] = AIR_NAN; } info->boundary = nrrdDefaultResampleBoundary; info->type = nrrdDefaultResampleType; info->renormalize = nrrdDefaultResampleRenormalize; info->round = nrrdDefaultResampleRound; info->clamp = nrrdDefaultResampleClamp; info->cheap = nrrdDefaultResampleCheap; info->padValue = nrrdDefaultResamplePadValue; } NrrdResampleInfo * 364 nrrdResampleInfoNew( void ) { NrrdResampleInfo *info; info = ( NrrdResampleInfo* )( calloc( 1, sizeof( NrrdResampleInfo ) ) ); if ( info ) { /* explicitly sets pointers to NULL */ _nrrdResampleInfoInit( info ); } return info; } NrrdResampleInfo * 376 nrrdResampleInfoNix( NrrdResampleInfo *info ) { info = ( NrrdResampleInfo * )airFree( info ); return NULL; } /* ------------------------------------------------------------ */ NrrdKernelSpec * 385 nrrdKernelSpecNew( void ) { NrrdKernelSpec *ksp; int i; ksp = ( NrrdKernelSpec * )calloc( 1, sizeof( NrrdKernelSpec ) ); if ( ksp ) { ksp->kernel = NULL; for ( i=0; i<NRRD_KERNEL_PARMS_NUM; i++ ) { ksp->parm[i] = airNaN( ); /* valgrind complained about AIR_NAN at -O2 */ } } return ksp; } NrrdKernelSpec * 400 nrrdKernelSpecCopy( const NrrdKernelSpec *oldKsp ) { NrrdKernelSpec *ksp=NULL; if ( oldKsp ) { ksp = ( NrrdKernelSpec * )calloc( 1, sizeof( NrrdKernelSpec ) ); if ( ksp ) { memcpy( ksp, oldKsp, sizeof( NrrdKernelSpec ) ); } } return ksp; } NrrdKernelSpec * 413 nrrdKernelSpecNix( NrrdKernelSpec *ksp ) { ksp = ( NrrdKernelSpec * )airFree( ksp ); return NULL; } void 420 nrrdKernelSpecSet( NrrdKernelSpec *ksp, const NrrdKernel *k, const double kparm[NRRD_KERNEL_PARMS_NUM] ) { unsigned int p; if ( ksp && k && kparm ) { ksp->kernel = k; for ( p=0; p<( k->numParm ); p++ ) { ksp->parm[p] = kparm[p]; } } } void 433 nrrdKernelParmSet( const NrrdKernel **kP, double kparm[NRRD_KERNEL_PARMS_NUM], NrrdKernelSpec *ksp ) { int p; if ( kP && kparm && ksp ) { *kP = ksp->kernel; for ( p=0; p<NRRD_KERNEL_PARMS_NUM; p++ ) { kparm[p] = ksp->parm[p]; } } } /* ---- END non-NrrdIO */ /* ------------------------------------------------------------ */ /* see axis.c for axis-specific "methods" */ /* ------------------------------------------------------------ */ /* ******** nrrdBasicInfoInit ** ** resets "basic" ( per-array ) information ** formerly nrrdPeripheralInit ** ** the bitflag communicates which fields should *not* be initialized */ void 462 nrrdBasicInfoInit( Nrrd *nrrd, int bitflag ) { int dd, ee; if ( !nrrd ) { return; } if ( !( NRRD_BASIC_INFO_DATA_BIT & bitflag ) ) { nrrd->data = airFree( nrrd->data ); } if ( !( NRRD_BASIC_INFO_TYPE_BIT & bitflag ) ) { nrrd->type = nrrdTypeUnknown; } if ( !( NRRD_BASIC_INFO_BLOCKSIZE_BIT & bitflag ) ) { nrrd->blockSize = 0; } if ( !( NRRD_BASIC_INFO_DIMENSION_BIT & bitflag ) ) { nrrd->dim = 0; } if ( !( NRRD_BASIC_INFO_CONTENT_BIT & bitflag ) ) { nrrd->content = ( char * )airFree( nrrd->content ); } if ( !( NRRD_BASIC_INFO_SAMPLEUNITS_BIT & bitflag ) ) { nrrd->sampleUnits = ( char * )airFree( nrrd->sampleUnits ); } if ( !( NRRD_BASIC_INFO_SPACE_BIT & bitflag ) ) { nrrd->space = nrrdSpaceUnknown; nrrd->spaceDim = 0; } if ( !( NRRD_BASIC_INFO_SPACEDIMENSION_BIT & bitflag ) ) { nrrd->space = nrrdSpaceUnknown; nrrd->spaceDim = 0; } if ( !( NRRD_BASIC_INFO_SPACEUNITS_BIT & bitflag ) ) { for ( dd=0; dd<NRRD_SPACE_DIM_MAX; dd++ ) { nrrd->spaceUnits[dd] = ( char * )airFree( nrrd->spaceUnits[dd] ); } } if ( !( NRRD_BASIC_INFO_SPACEORIGIN_BIT & bitflag ) ) { for ( dd=0; dd<NRRD_SPACE_DIM_MAX; dd++ ) { nrrd->spaceOrigin[dd] = AIR_NAN; } } if ( !( NRRD_BASIC_INFO_MEASUREMENTFRAME_BIT & bitflag ) ) { for ( dd=0; dd<NRRD_SPACE_DIM_MAX; dd++ ) { for ( ee=0; ee<NRRD_SPACE_DIM_MAX; ee++ ) { nrrd->measurementFrame[dd][ee] = AIR_NAN; } } } if ( !( NRRD_BASIC_INFO_OLDMIN_BIT & bitflag ) ) { nrrd->oldMin = AIR_NAN; } if ( !( NRRD_BASIC_INFO_OLDMAX_BIT & bitflag ) ) { nrrd->oldMax = AIR_NAN; } if ( !( NRRD_BASIC_INFO_COMMENTS_BIT & bitflag ) ) { nrrdCommentClear( nrrd ); } if ( !( NRRD_BASIC_INFO_KEYVALUEPAIRS_BIT & bitflag ) ) { nrrdKeyValueClear( nrrd ); } return; } /* ******** nrrdBasicInfoCopy ** ** copies "basic" ( per-array ) information ** formerly known as nrrdPeripheralCopy, which was not used consistently ** ** the bitflag communicates which fields should *not* be copied */ int 536 nrrdBasicInfoCopy( Nrrd *dest, const Nrrd *src, int bitflag ) { static const char me[]="nrrdBasicInfoCopy"; unsigned int dd, ee; if ( !( dest && src ) ) return 0; if ( dest == src ) { /* nothing to do */ return 0; } if ( !( NRRD_BASIC_INFO_DATA_BIT & bitflag ) ) { dest->data = src->data; } if ( !( NRRD_BASIC_INFO_TYPE_BIT & bitflag ) ) { dest->type = src->type; } if ( !( NRRD_BASIC_INFO_BLOCKSIZE_BIT & bitflag ) ) { dest->blockSize = src->blockSize; } if ( !( NRRD_BASIC_INFO_DIMENSION_BIT & bitflag ) ) { dest->dim = src->dim; } if ( !( NRRD_BASIC_INFO_CONTENT_BIT & bitflag ) ) { dest->content = ( char * )airFree( dest->content ); dest->content = airStrdup( src->content ); if ( src->content && !dest->content ) { biffAddf( NRRD, "%s: couldn't copy content", me ); return 1; } } if ( !( NRRD_BASIC_INFO_SAMPLEUNITS_BIT & bitflag ) ) { dest->sampleUnits = ( char * )airFree( dest->sampleUnits ); dest->sampleUnits = airStrdup( src->sampleUnits ); if ( src->sampleUnits && !dest->sampleUnits ) { biffAddf( NRRD, "%s: couldn't copy sampleUnits", me ); return 1; } } if ( !( NRRD_BASIC_INFO_SPACE_BIT & bitflag ) ) { dest->space = src->space; } if ( !( NRRD_BASIC_INFO_SPACEDIMENSION_BIT & bitflag ) ) { dest->spaceDim = src->spaceDim; } if ( !( NRRD_BASIC_INFO_SPACEUNITS_BIT & bitflag ) ) { for ( dd=0; dd<src->spaceDim; dd++ ) { dest->spaceUnits[dd] = ( char * )airFree( dest->spaceUnits[dd] ); dest->spaceUnits[dd] = airStrdup( src->spaceUnits[dd] ); if ( src->spaceUnits[dd] && !dest->spaceUnits[dd] ) { biffAddf( NRRD, "%s: couldn't copy spaceUnits[%d]", me, dd ); return 1; } } for ( dd=src->spaceDim; dd<NRRD_SPACE_DIM_MAX; dd++ ) { dest->spaceUnits[dd] = ( char * )airFree( dest->spaceUnits[dd] ); } } if ( !( NRRD_BASIC_INFO_SPACEORIGIN_BIT & bitflag ) ) { for ( dd=0; dd<NRRD_SPACE_DIM_MAX; dd++ ) { if ( dd <= src->spaceDim-1 ) { dest->spaceOrigin[dd] = src->spaceOrigin[dd]; } else { dest->spaceOrigin[dd] = AIR_NAN; } } } if ( !( NRRD_BASIC_INFO_MEASUREMENTFRAME_BIT & bitflag ) ) { for ( dd=0; dd<NRRD_SPACE_DIM_MAX; dd++ ) { for ( ee=0; ee<NRRD_SPACE_DIM_MAX; ee++ ) { if ( dd <= src->spaceDim-1 && ee <= src->spaceDim-1 ) { dest->measurementFrame[dd][ee] = src->measurementFrame[dd][ee]; } else { dest->measurementFrame[dd][ee] = AIR_NAN; } } } for ( dd=src->spaceDim; dd<NRRD_SPACE_DIM_MAX; dd++ ) { dest->spaceOrigin[dd] = AIR_NAN; } } if ( !( NRRD_BASIC_INFO_OLDMIN_BIT & bitflag ) ) { dest->oldMin = src->oldMin; } if ( !( NRRD_BASIC_INFO_OLDMAX_BIT & bitflag ) ) { dest->oldMax = src->oldMax; } if ( !( NRRD_BASIC_INFO_COMMENTS_BIT & bitflag ) ) { if ( nrrdCommentCopy( dest, src ) ) { biffAddf( NRRD, "%s: trouble copying comments", me ); return 1; } } if ( !( NRRD_BASIC_INFO_KEYVALUEPAIRS_BIT & bitflag ) ) { if ( nrrdKeyValueCopy( dest, src ) ) { biffAddf( NRRD, "%s: trouble copying key/value pairs", me ); return 1; } } return 0; } /* ******* nrrdInit ** ** initializes a nrrd to default state. All nrrd functions in the ** business of initializing a nrrd struct use this function. Mostly ** just sets values to 0, NaN, "", NULL, or Unknown */ void 646 nrrdInit( Nrrd *nrrd ) { int ii; if ( nrrd ) { nrrdBasicInfoInit( nrrd, NRRD_BASIC_INFO_NONE ); for ( ii=0; ii<NRRD_DIM_MAX; ii++ ) { _nrrdAxisInfoInit( nrrd->axis + ii ); } } return; } /* ******** nrrdNew( ) ** ** creates and initializes a Nrrd ** ** this does NOT use biff */ Nrrd * 666 nrrdNew( void ) { int ii; Nrrd *nrrd; airPtrPtrUnion appu; nrrd = ( Nrrd* )( calloc( 1, sizeof( Nrrd ) ) ); if ( !nrrd ) { return NULL; } /* explicitly set pointers to NULL, since calloc isn't officially guaranteed to do that. */ nrrd->data = NULL; for ( ii=0; ii<NRRD_DIM_MAX; ii++ ) { _nrrdAxisInfoNewInit( nrrd->axis + ii ); } for ( ii=0; ii<NRRD_SPACE_DIM_MAX; ii++ ) { nrrd->spaceUnits[ii] = NULL; } nrrd->content = NULL; nrrd->sampleUnits = NULL; /* create comment airArray ( even though it starts empty ) */ nrrd->cmt = NULL; appu.cp = &( nrrd->cmt ); nrrd->cmtArr = airArrayNew( appu.v, NULL, sizeof( char * ), NRRD_COMMENT_INCR ); if ( !nrrd->cmtArr ) { return NULL; } airArrayPointerCB( nrrd->cmtArr, airNull, airFree ); /* create key/value airArray ( even thought it starts empty ) */ nrrd->kvp = NULL; appu.cp = &( nrrd->kvp ); nrrd->kvpArr = airArrayNew( appu.v, NULL, 2*sizeof( char * ), NRRD_KEYVALUE_INCR ); if ( !nrrd->kvpArr ) { return NULL; } /* key/value airArray uses no callbacks for now */ /* finish initializations */ nrrdInit( nrrd ); return nrrd; } /* ******** nrrdNix( ) ** ** does nothing with the array data inside, just does whatever is needed ** to free the nrrd itself ** ** returns NULL ** ** this does NOT use biff */ Nrrd * 724 nrrdNix( Nrrd *nrrd ) { int ii; if ( nrrd ) { for ( ii=0; ii<NRRD_DIM_MAX; ii++ ) { _nrrdAxisInfoInit( &( nrrd->axis[ii] ) ); } for ( ii=0; ii<NRRD_SPACE_DIM_MAX; ii++ ) { nrrd->spaceUnits[ii] = ( char * )airFree( nrrd->spaceUnits[ii] ); } nrrd->content = ( char * )airFree( nrrd->content ); nrrd->sampleUnits = ( char * )airFree( nrrd->sampleUnits ); nrrdCommentClear( nrrd ); nrrd->cmtArr = airArrayNix( nrrd->cmtArr ); nrrdKeyValueClear( nrrd ); nrrd->kvpArr = airArrayNix( nrrd->kvpArr ); airFree( nrrd ); } return NULL; } /* ******** nrrdEmpty( ) ** ** frees data inside nrrd AND resets all its state, so its the ** same as what comes from nrrdNew( ). This includes free( )ing ** any comments. */ Nrrd * 753 nrrdEmpty( Nrrd *nrrd ) { if ( nrrd ) { nrrd->data = airFree( nrrd->data ); nrrdInit( nrrd ); } return nrrd; } /* ******** nrrdNuke( ) ** ** blows away the nrrd and everything inside ** ** always returns NULL */ Nrrd * 770 nrrdNuke( Nrrd *nrrd ) { if ( nrrd ) { nrrdEmpty( nrrd ); nrrdNix( nrrd ); } return NULL; } /* ------------------------------------------------------------ */ int 782 _nrrdSizeCheck( const size_t *size, unsigned int dim, int useBiff ) { static const char me[]="_nrrdSizeCheck"; size_t num, pre; unsigned int ai; pre = num = 1; for ( ai=0; ai<dim; ai++ ) { if ( !size[ai] ) { biffMaybeAddf( useBiff, NRRD, "%s: axis %u size is zero!", me, ai ); return 1; } num *= size[ai]; if ( num/size[ai] != pre ) { biffMaybeAddf( useBiff, NRRD, "%s: total # of elements too large to be represented in " "type size_t, so too large for current architecture", me ); return 1; } pre *= size[ai]; } return 0; } /* ******** nrrdWrap_nva( ) ** ** wraps a given Nrrd around a given array ** ** we don't touch any of the peripheral information ( content, comments, ** blocksize, min/max ) because it is entirely reasonable to be setting ** this before or after this call. "type" could be passed as ** nrrdTypeBlock, in which case it is the user's responsibility to ** set nrrd->blockSize at some other time. */ int 817 nrrdWrap_nva( Nrrd *nrrd, void *data, int type, unsigned int dim, const size_t *size ) { static const char me[]="nrrdWrap_nva"; if ( !( nrrd && size ) ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } nrrd->data = data; nrrd->type = type; nrrd->dim = dim; if ( _nrrdSizeCheck( size, dim, AIR_TRUE ) ) { biffAddf( NRRD, "%s:", me ); return 1; } nrrdAxisInfoSet_nva( nrrd, nrrdAxisInfoSize, size ); return 0; } /* ******** nrrdWrap_va( ) ** ** Minimal var args wrapper around nrrdWrap_nva, with the advantage of ** taking all the axes sizes as the var args. ** ** This is THE BEST WAY to wrap a nrrd around existing raster data, ** assuming that the dimension is known at compile time. ** ** If successful, returns 0, otherwise, 1. ** This does use biff. */ int 849 nrrdWrap_va( Nrrd *nrrd, void *data, int type, unsigned int dim, ... ) { static const char me[]="nrrdWrap_va"; va_list ap; size_t size[NRRD_DIM_MAX]; unsigned int ai; if ( !( nrrd && data ) ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } va_start( ap, dim ); for ( ai=0; ai<dim; ai++ ) { size[ai] = va_arg( ap, size_t ); } va_end( ap ); return nrrdWrap_nva( nrrd, data, type, dim, size ); } /* void _nrrdTraverse( Nrrd *nrrd ) { char *test, tval; size_t I, N; int S; N = nrrdElementNumber( nrrd ); S = nrrdElementSize( nrrd ); tval = 0; test = nrrd->data; for ( I=0; I<N*S; I++ ) { tval += test[I]; } } */ int 886 _nrrdCopy( Nrrd *nout, const Nrrd *nin, int bitflag ) { static const char me[]="_nrrdCopy"; size_t size[NRRD_DIM_MAX]; if ( !( nin && nout ) ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( nout == nin ) { /* its not the case that we have nothing to do- the semantics of copying cannot be achieved if the input and output nrrd are the same; this is an error */ biffAddf( NRRD, "%s: nout==nin disallowed", me ); return 1; } if ( !nrrdElementSize( nin ) ) { biffAddf( NRRD, "%s: input nrrd reports zero element size!", me ); return 1; } nrrdAxisInfoGet_nva( nin, nrrdAxisInfoSize, size ); if ( nin->data ) { if ( nrrdMaybeAlloc_nva( nout, nin->type, nin->dim, size ) ) { biffAddf( NRRD, "%s: couldn't allocate data", me ); return 1; } memcpy( nout->data, nin->data, nrrdElementNumber( nin )*nrrdElementSize( nin ) ); } else { /* someone is trying to copy structs without data, fine fine fine */ if ( nrrdWrap_nva( nout, NULL, nin->type, nin->dim, size ) ) { biffAddf( NRRD, "%s: couldn't wrap NULL data", me ); return 1; } } nrrdAxisInfoCopy( nout, nin, NULL, NRRD_AXIS_INFO_SIZE_BIT ); /* if nin->data non-NULL ( second branch above ), this will harmlessly unset and set type and dim */ nrrdBasicInfoInit( nout, NRRD_BASIC_INFO_DATA_BIT | bitflag ); if ( nrrdBasicInfoCopy( nout, nin, NRRD_BASIC_INFO_DATA_BIT | bitflag ) ) { biffAddf( NRRD, "%s: trouble copying basic info", me ); return 1; } return 0; } /* ******** nrrdCopy ** ** copy method for nrrds. nout will end up as an "exact" copy of nin. ** New space for data is allocated here, and output nrrd points to it. ** Comments from old are added to comments for new, so these are also ** newly allocated. nout->ptr is not set, nin->ptr is not read. */ int 941 nrrdCopy( Nrrd *nout, const Nrrd *nin ) { static const char me[]="nrrdCopy"; if ( _nrrdCopy( nout, nin, NRRD_BASIC_INFO_NONE ) ) { biffAddf( NRRD, "%s:", me ); return 1; } return 0; } /* ******** nrrdAlloc_nva( ) ** ** allocates data array and sets information. If this is a block type ** nrrd, it is necessary to set nrrd->blockSize PRIOR to calling ** this function. ** ** This function will always allocate more memory ( via calloc ), but ** it will free( ) nrrd->data if it is non-NULL when passed in. ** ** This function takes the same "don't mess with peripheral information" ** attitude as nrrdWrap( ). ** ** Note to Gordon: don't get clever and change ANY axis-specific ** information here. It may be very convenient to set that before ** nrrdAlloc or nrrdMaybeAlloc ** ** Note: This function DOES use biff */ int 971 nrrdAlloc_nva( Nrrd *nrrd, int type, unsigned int dim, const size_t *size ) { static const char me[]="nrrdAlloc_nva"; size_t num, esize; char stmp[2][AIR_STRLEN_SMALL]; if ( !( nrrd && size ) ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( airEnumValCheck( nrrdType, type ) ) { biffAddf( NRRD, "%s: type ( %d ) is invalid", me, type ); return 1; } if ( nrrdTypeBlock == type ) { if ( !( 0 < nrrd->blockSize ) ) { biffAddf( NRRD, "%s: given nrrd->blockSize %s invalid", me, airSprintSize_t( stmp[0], nrrd->blockSize ) ); return 1; } } if ( !AIR_IN_CL( 1, dim, NRRD_DIM_MAX ) ) { biffAddf( NRRD, "%s: dim ( %d ) not in valid range [1, %d]", me, dim, NRRD_DIM_MAX ); return 1; } nrrd->data = airFree( nrrd->data ); if ( nrrdWrap_nva( nrrd, NULL, type, dim, size ) ) { biffAddf( NRRD, "%s:", me ); return 1 ; } num = nrrdElementNumber( nrrd ); esize = nrrdElementSize( nrrd ); nrrd->data = calloc( num, esize ); if ( !( nrrd->data ) ) { biffAddf( NRRD, "%s: calloc( %s, %s ) failed", me, airSprintSize_t( stmp[0], num ), airSprintSize_t( stmp[1], esize ) ); return 1 ; } return 0; } /* ******** nrrdAlloc_va( ) ** ** Handy wrapper around nrrdAlloc_nva, which takes, as its vararg list, ** all the axes sizes. */ int 1022 nrrdAlloc_va( Nrrd *nrrd, int type, unsigned int dim, ... ) { static const char me[]="nrrdAlloc_va"; size_t size[NRRD_DIM_MAX]; unsigned int ai; va_list ap; if ( !nrrd ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } va_start( ap, dim ); for ( ai=0; ai<dim; ai++ ) { size[ai] = va_arg( ap, size_t ); } va_end( ap ); if ( nrrdAlloc_nva( nrrd, type, dim, size ) ) { biffAddf( NRRD, "%s:", me ); return 1; } return 0; } /* ** _nrrdMaybeAllocMaybeZero_nva ** ** New implementation of nrrdMaybeAlloc_nva, but now with ability ** to control whether or not to zero out when re-allocation wasn't needed ** ** HEY: should consider making this a public function, but GLK couldn't ** think of a name that wasn't silly */ int 1055 _nrrdMaybeAllocMaybeZero_nva( Nrrd *nrrd, int type, unsigned int dim, const size_t *size, int zeroWhenNoAlloc ) { static const char me[]="nrrdMaybeAllocMaybeZero_nva"; size_t sizeWant, sizeHave, numWant, elementSizeWant; int need; unsigned int ai; if ( !nrrd ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( airEnumValCheck( nrrdType, type ) ) { biffAddf( NRRD, "%s: type ( %d ) is invalid", me, type ); return 1; } if ( nrrdTypeBlock == type ) { if ( nrrdTypeBlock == nrrd->type ) { biffAddf( NRRD, "%s: can't change from one block nrrd to another", me ); return 1; } if ( !( 0 < nrrd->blockSize ) ) { char stmp[AIR_STRLEN_SMALL]; biffAddf( NRRD, "%s: given nrrd->blockSize %s invalid", me, airSprintSize_t( stmp, nrrd->blockSize ) ); return 1; } elementSizeWant = nrrd->blockSize; } else { elementSizeWant = nrrdTypeSize[type]; } if ( _nrrdSizeCheck( size, dim, AIR_TRUE ) ) { biffAddf( NRRD, "%s:", me ); return 1; } if ( !( nrrd->data ) ) { need = 1; } else { numWant = 1; for ( ai=0; ai<dim; ai++ ) { numWant *= size[ai]; } if ( !nrrdElementSize( nrrd ) ) { biffAddf( NRRD, "%s: nrrd reports zero element size!", me ); return 1; } sizeHave = nrrdElementNumber( nrrd ) * nrrdElementSize( nrrd ); /* fprintf( stderr, "##%s: sizeHave = %d * %d = %d\n", me, ( int )( nrrdElementNumber( nrrd ) ), ( int )( nrrdElementSize( nrrd ) ), ( int )sizeHave ); */ sizeWant = numWant * elementSizeWant; /* fprintf( stderr, "##%s: sizeWant = %d * %d = %d\n", me, ( int )( numWant ), ( int )( elementSizeWant ), ( int )sizeWant ); */ need = sizeHave != sizeWant; /* fprintf( stderr, "##%s: need = %d\n", me, need ); */ } if ( need ) { if ( nrrdAlloc_nva( nrrd, type, dim, size ) ) { biffAddf( NRRD, "%s:", me ); return 1; } } else { /* size is already exactly what we want */ if ( nrrdWrap_nva( nrrd, nrrd->data, type, dim, size ) ) { biffAddf( NRRD, "%s:", me ); return 1; } /* but we may have to initialize memory */ if ( zeroWhenNoAlloc ) { memset( nrrd->data, 0, nrrdElementNumber( nrrd )*nrrdElementSize( nrrd ) ); } } return 0; } /* ******** nrrdMaybeAlloc_nva ** ** NOTE: this is now just a wrapper around _nrrdMaybeAllocMaybeZero_nva; ** below info referred to original implementation. ** ** calls nrrdAlloc_nva if the requested space is different than ** what is currently held ** ** also subscribes to the "don't mess with peripheral information" philosophy */ int 1145 nrrdMaybeAlloc_nva( Nrrd *nrrd, int type, unsigned int dim, const size_t *size ) { static const char me[]="nrrdMaybeAlloc_nva"; int ret; ret = _nrrdMaybeAllocMaybeZero_nva( nrrd, type, dim, size, AIR_TRUE ); if ( ret ) { biffAddf( NRRD, "%s: trouble", me ); } return ret; } /* ******** nrrdMaybeAlloc_va( ) ** ** Handy wrapper around nrrdAlloc, which takes, as its vararg list ** all the axes sizes, thereby calculating the total number. */ int 1164 nrrdMaybeAlloc_va( Nrrd *nrrd, int type, unsigned int dim, ... ) { static const char me[]="nrrdMaybeAlloc_va"; size_t size[NRRD_DIM_MAX]; unsigned int ai; va_list ap; if ( !nrrd ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } va_start( ap, dim ); for ( ai=0; ai<dim; ai++ ) { size[ai] = va_arg( ap, size_t ); } va_end( ap ); if ( nrrdMaybeAlloc_nva( nrrd, type, dim, size ) ) { biffAddf( NRRD, "%s:", me ); return 1; } return 0; } /* ---- BEGIN non-NrrdIO */ /* ** nrrdCompare ** ** walks through all fields of the two nrrds to see if they contain ** the same information. So, this doesn't compare any pointer values, ** only the contents of things. ** ** Unlike strcmp( ), the return value from this can't be the indication ** of the difference, because we'd have to return a value even in the ** case of an error, which would be be strange. GLK briefly tried ** created a new #define _NRRD_ERROR_RETURN for this purpose ( with ** leet-speak value 32202 ), but its just a bad idea. ** ** NOTE: the structure of this code is very similar to that of ** nrrdAxisInfoCompare, and any improvements here should be reflected there */ int 1205 nrrdCompare( const Nrrd *ninA, const Nrrd *ninB, int onlyData, double epsilon, int *differ, char explain[AIR_STRLEN_LARGE] ) { static const char me[]="nrrdCompare"; size_t numA, numB; unsigned int axi, saxi; if ( !( ninA && ninB && differ ) ) { biffAddf( NRRD, "%s: got NULL pointer ( %p, %p, or %p )", me, AIR_CVOIDP( ninA ), AIR_CVOIDP( ninB ), AIR_VOIDP( differ ) ); return 1; } if ( explain ) { strcpy( explain, "" ); } if ( !onlyData ) { if ( ninA->dim != ninB->dim ) { *differ = ninA->dim < ninB->dim ? -1 : 1; if ( explain ) { sprintf( explain, "nin{A, B}->dim %u %s %u", ninA->dim, *differ < 0 ? "<" : ">", ninB->dim ); } return 0; } } if ( ninA->type != ninB->type ) { *differ = ninA->type < ninB->type ? -1 : 1; if ( explain ) { sprintf( explain, "nin{A, B}->type %s %s %s", airEnumStr( nrrdType, ninA->type ), *differ < 0 ? "<" : ">", airEnumStr( nrrdType, ninB->type ) ); } return 0; } numA = nrrdElementNumber( ninA ); numB = nrrdElementNumber( ninB ); if ( numA != numB ) { char stmp1[AIR_STRLEN_SMALL], stmp2[AIR_STRLEN_SMALL]; *differ = numA < numB ? -1 : 1; sprintf( explain, "element # {A, B} %s %s %s", airSprintSize_t( stmp1, numA ), *differ < 0 ? "<" : ">", airSprintSize_t( stmp2, numB ) ); return 0; } /* this will always set *differ */ if ( nrrdArrayCompare( ninA->type, ninA->data, ninB->data, numA, epsilon, differ, explain ) ) { biffAddf( NRRD, "%s: problem comparing values", me ); return 1; } if ( onlyData || *differ ) { /* If caller only cared about data values, we're done whether or not they were different. else, if the data values are different, we're done. The explanation of any difference in values is already in "explain" ( if non-NULL ) */ return 0; } for ( axi=0; axi<ninA->dim; axi++ ) { /* this always sets *differ */ if ( nrrdAxisInfoCompare( ninA->axis + axi, ninB->axis + axi, differ, explain ) ) { biffAddf( NRRD, "%s: problem comparing axis %u", me, axi ); return 1; } if ( *differ ) { char tmpexplain[AIR_STRLEN_LARGE]; /* the explanation, if wanted, is in "explain", but we add context */ sprintf( tmpexplain, "( axis %u ) %s", axi, explain ); airStrcpy( explain, AIR_STRLEN_LARGE, tmpexplain ); return 0; } } #define STRING_COMPARE( VAL, STR ) \ *differ = airStrcmp( ninA->VAL, ninB->VAL ); \ if ( *differ ) { \ if ( explain ) { \ /* can't print whole string because of fixed-size of explain */ \ sprintf( explain, "ninA->%s %s ninB->%s", \ STR, *differ < 0 ? "<" : ">", STR ); \ } \ return 0; \ } STRING_COMPARE( content, "content" ); STRING_COMPARE( sampleUnits, "sampleUnits" ); if ( ninA->space != ninB->space ) { *differ = ninA->space < ninB->space ? -1 : 1; if ( explain ) { sprintf( explain, "ninA->space %s %s ninB->space %s", airEnumStr( nrrdSpace, ninA->space ), *differ < 0 ? "<" : ">", airEnumStr( nrrdSpace, ninB->space ) ); } return 0; } if ( ninA->spaceDim != ninB->spaceDim ) { *differ = ninA->spaceDim < ninB->spaceDim ? -1 : 1; if ( explain ) { sprintf( explain, "ninA->spaceDim %u %s ninB->spaceDim %u", ninA->spaceDim, *differ < 0 ? "<" : ">", ninB->spaceDim ); } return 0; } if ( ninA->blockSize != ninB->blockSize ) { *differ = ninA->blockSize < ninB->blockSize ? -1 : 1; if ( explain ) { char stmp1[AIR_STRLEN_SMALL], stmp2[AIR_STRLEN_SMALL]; sprintf( explain, "ninA->blockSize %s %s ninB->blockSize %s", airSprintSize_t( stmp1, ninA->blockSize ), *differ < 0 ? "<" : ">", airSprintSize_t( stmp2, ninB->blockSize ) ); } return 0; } #define DOUBLE_COMPARE( VAL, STR ) \ *differ = _nrrdDblcmp( ninA->VAL, ninB->VAL ); \ if ( *differ ) { \ if ( explain ) { \ sprintf( explain, "ninA->%s %.17g %s ninB->%s %.17g", \ STR, ninA->VAL, *differ < 0 ? "<" : ">", \ STR, ninB->VAL ); \ } \ return 0; \ } for ( saxi=0; saxi<NRRD_SPACE_DIM_MAX; saxi++ ) { char stmp[AIR_STRLEN_SMALL]; unsigned int saxj; sprintf( stmp, "spaceOrigin[%u]", saxi ); DOUBLE_COMPARE( spaceOrigin[saxi], stmp ); sprintf( stmp, "spaceUnits[%u]", saxi ); STRING_COMPARE( spaceUnits[saxi], stmp ); for ( saxj=0; saxj<NRRD_SPACE_DIM_MAX; saxj++ ) { sprintf( stmp, "measurementFrame[%u][%u]", saxi, saxj ); DOUBLE_COMPARE( measurementFrame[saxi][saxj], stmp ); } } DOUBLE_COMPARE( oldMin, "oldMin" ); DOUBLE_COMPARE( oldMax, "oldMax" ); #undef DOUBLE_COMPARE if ( ninA->cmtArr->len != ninB->cmtArr->len ) { *differ = ninA->cmtArr->len < ninB->cmtArr->len ? -1 : 1; if ( explain ) { sprintf( explain, "ninA # comments %u %s ninB # comments %u", ninA->cmtArr->len, *differ < 0 ? "<" : ">", ninB->cmtArr->len ); } return 0; } else { unsigned int ii; char stmp[AIR_STRLEN_SMALL]; for ( ii=0; ii<ninA->cmtArr->len; ii++ ) { sprintf( stmp, "comment[%u]", ii ); STRING_COMPARE( cmt[ii], stmp ); } } if ( ninA->kvpArr->len != ninB->kvpArr->len ) { *differ = ninA->kvpArr->len < ninB->kvpArr->len ? -1 : 1; if ( explain ) { sprintf( explain, "ninA # key/values %u %s ninB # key/values %u", ninA->kvpArr->len, *differ < 0 ? "<" : ">", ninB->kvpArr->len ); } return 0; } else { unsigned int ii; char stmp[AIR_STRLEN_SMALL]; for ( ii=0; ii<ninA->kvpArr->len; ii++ ) { sprintf( stmp, "key/value key[%u]", ii ); STRING_COMPARE( kvp[2*ii + 0], stmp ); sprintf( stmp, "key/value value[%u]", ii ); STRING_COMPARE( kvp[2*ii + 1], stmp ); } } #undef STRING_COMPARE /* ninA->ptr and ninB->ptr are not to be accessed */ /* if we've gotten this far, all fields were equal */ *differ = 0; return 0; } /* ******** nrrdPPM( ) ** ** for making a nrrd suitable for holding PPM data ** ** "don't mess with peripheral information" */ int nrrdPPM( Nrrd *ppm, size_t sx, size_t sy ) { static const char me[]="nrrdPPM"; char stmp[2][AIR_STRLEN_SMALL]; if ( nrrdMaybeAlloc_va( ppm, nrrdTypeUChar, 3, AIR_CAST( size_t, 3 ), sx, sy ) ) { biffAddf( NRRD, "%s: couldn't allocate %s x %s 24-bit image", me, airSprintSize_t( stmp[0], sx ), airSprintSize_t( stmp[1], sy ) ); return 1; } return 0; } /* ******** nrrdPGM( ) ** ** for making a nrrd suitable for holding PGM data ** ** "don't mess with peripheral information" */ int nrrdPGM( Nrrd *pgm, size_t sx, size_t sy ) { static const char me[]="nrrdPGM"; char stmp[2][AIR_STRLEN_SMALL]; if ( nrrdMaybeAlloc_va( pgm, nrrdTypeUChar, 2, sx, sy ) ) { biffAddf( NRRD, "%s: couldn't allocate %s x %s 8-bit image", me, airSprintSize_t( stmp[0], sx ), airSprintSize_t( stmp[1], sy ) ); return 1; } return 0; } /* ---- END non-NrrdIO */

/Users/scm/git/github/teem/src/nrrd/parseNrrd.c

/Users/scm/git/github/teem/src/nrrd/range.c

/Users/scm/git/github/teem/src/nrrd/read.c

/Users/scm/git/github/teem/src/nrrd/reorder.c

/Users/scm/git/github/teem/src/nrrd/resampleContext.c

/* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2013, 2012, 2011, 2010, 2009 University of Chicago Copyright ( C ) 2008, 2007, 2006, 2005 Gordon Kindlmann Copyright ( C ) 2004, 2003, 2002, 2001, 2000, 1999, 1998 University of Utah This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "nrrd.h" #include "privateNrrd.h" /* ** This is a largely a re-write of the functionality in ** nrrdSpatialResample( ), but with some improvements. The big API ** change is that everything happens in a nrrdResampleContext, and no ** fields in this need to be directly set ( except for rsmc->verbose ). ** ** The big behavior/API change is that the range along the axis that ** is resampled is now defined in terms of index space, instead of ** axis-aligned scaled index space ( what used to be called "world ** space", prior to general orientation ). This means that if you ** want the whole range resampled, you use [-0.5, size-0.5] for cell- ** centered, and [0, size-1] for node-centered. One function helpful ** dealing with this is nrrdResampleRangeFullSet( ). ** ** Other improvements: ** -- ability to quickly resample a different nrrd with the same ** sizes and kernels as with a previous ( all useful state and ** allocations of intermediate resampling results is preserved ** in the nrrdResampleContext ). To resample a second nrrd, ** you'd only need: ** nrrdResampleInputSet( rsmc, nin2 ); ** nrrdResampleExecute( rsmc, nout2 ); ** -- correct handling general orientation ( space directions and ** space origin ). This was impossible in the old resampler ** because of how its logic was hard-wired to the axis-aligned ** world space defined by the per-axis min and max. ** -- correct handling of "cheap" downsampling, with the use of ** the new nrrdKernelCheap ** -- smaller memory footprint ( smarter about freeing intermediate ** resampling results ) */ enum { flagUnknown, /* 0 */ flagDefaultCenter, /* 1 */ flagInput, /* 2 */ flagOverrideCenters, /* 3 */ flagInputDimension, /* 4 */ flagInputCenters, /* 5 */ flagInputSizes, /* 6 */ flagKernels, /* 7 */ flagSamples, /* 8 */ flagRanges, /* 9 */ flagBoundary, /* 10 */ flagLineAllocate, /* 11 */ flagLineFill, /* 12 */ flagVectorAllocate, /* 13 */ flagPermutation, /* 14 */ flagVectorFill, /* 15 */ flagClamp, /* 16 */ flagRound, /* 17 */ flagTypeOut, /* 18 */ flagPadValue, /* 19 */ flagRenormalize, /* 20 */ flagNonExistent, /* 21 */ flagLast }; #define FLAG_MAX 21 void 87 nrrdResampleContextInit( NrrdResampleContext *rsmc ) { unsigned int axIdx, axJdx, kpIdx, flagIdx; NrrdResampleAxis *axis; if ( rsmc ) { rsmc->nin = NULL; rsmc->boundary = nrrdDefaultResampleBoundary; rsmc->typeOut = nrrdDefaultResampleType; rsmc->renormalize = nrrdDefaultResampleRenormalize; rsmc->roundlast = nrrdDefaultResampleRound; rsmc->clamp = nrrdDefaultResampleClamp; rsmc->defaultCenter = nrrdDefaultCenter; rsmc->nonExistent = nrrdDefaultResampleNonExistent; rsmc->padValue = nrrdDefaultResamplePadValue; rsmc->dim = 0; rsmc->passNum = AIR_CAST( unsigned int, -1 ); /* 4294967295 */ rsmc->topRax = AIR_CAST( unsigned int, -1 ); rsmc->botRax = AIR_CAST( unsigned int, -1 ); for ( axIdx=0; axIdx<NRRD_DIM_MAX; axIdx++ ) { rsmc->permute[axIdx] = AIR_CAST( unsigned int, -1 ); rsmc->passAxis[axIdx] = AIR_CAST( unsigned int, -1 ); } for ( axIdx=0; axIdx<NRRD_DIM_MAX+1; axIdx++ ) { axis = rsmc->axis + axIdx; axis->kernel = NULL; axis->kparm[0] = nrrdDefaultKernelParm0; for ( kpIdx=1; kpIdx<NRRD_KERNEL_PARMS_NUM; kpIdx++ ) { axis->kparm[kpIdx] = AIR_NAN; } axis->min = axis->max = AIR_NAN; axis->samples = AIR_CAST( unsigned int, -1 ); axis->overrideCenter = nrrdCenterUnknown; axis->center = nrrdCenterUnknown; axis->sizeIn = AIR_CAST( unsigned int, -1 ); axis->axIdx = axIdx; /* never changes */ axis->passIdx = AIR_CAST( unsigned int, -1 ); for ( axJdx=0; axJdx<NRRD_DIM_MAX; axJdx++ ) { axis->sizePerm[axJdx] = AIR_CAST( size_t, -1 ); axis->axisPerm[axJdx] = AIR_CAST( unsigned int, -1 ); } axis->ratio = AIR_NAN; axis->nrsmp = NULL; /* these are nrrdNew( )'d as needed */ axis->nline = nrrdNew( ); axis->nindex = nrrdNew( ); axis->nweight = nrrdNew( ); } /* initialize flags to all true */ for ( flagIdx=0; flagIdx<=FLAG_MAX; flagIdx++ ) { rsmc->flag[flagIdx] = AIR_TRUE; } rsmc->time = 0.0; } return; } NrrdResampleContext * 143 nrrdResampleContextNew( ) { NrrdResampleContext *rsmc; rsmc = AIR_CALLOC( 1, NrrdResampleContext ); if ( rsmc ) { rsmc->flag = AIR_CALLOC( 1+FLAG_MAX, int ); nrrdResampleContextInit( rsmc ); } return rsmc; } NrrdResampleContext * 155 nrrdResampleContextNix( NrrdResampleContext *rsmc ) { unsigned int axIdx; if ( rsmc ) { for ( axIdx=0; axIdx<NRRD_DIM_MAX+1; axIdx++ ) { /* nrsmp should have been cleaned up by _nrrdResampleOutputUpdate( ) */ nrrdNuke( rsmc->axis[axIdx].nline ); nrrdNuke( rsmc->axis[axIdx].nindex ); nrrdNuke( rsmc->axis[axIdx].nweight ); } airFree( rsmc->flag ); airFree( rsmc ); } return NULL; } int 172 nrrdResampleDefaultCenterSet( NrrdResampleContext *rsmc, int center ) { static const char me[]="nrrdResampleDefaultCenterSet"; if ( !( rsmc ) ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( !( nrrdCenterNode == center || nrrdCenterCell == center ) ) { biffAddf( NRRD, "%s: got invalid center ( %d )", me, center ); return 1; } if ( center != rsmc->defaultCenter ) { rsmc->defaultCenter = center; rsmc->flag[flagDefaultCenter] = AIR_TRUE; } return 0; } int 195 nrrdResampleNonExistentSet( NrrdResampleContext *rsmc, int nonExist ) { static const char me[]="nrrdResampleNonExistentSet"; if ( !( rsmc ) ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( airEnumValCheck( nrrdResampleNonExistent, nonExist ) ) { biffAddf( NRRD, "%s: didn't get valid non-existent behavior ( %d )", me, nonExist ); return 1; } if ( nonExist != rsmc->nonExistent ) { rsmc->nonExistent = nonExist; rsmc->flag[flagNonExistent] = AIR_TRUE; } return 0; } #define NRRD_RESAMPLE_INPUT_SET_BODY \ unsigned int axIdx, kpIdx; \ \ if ( !( rsmc && nin ) ) { \ biffAddf( NRRD, "%s: got NULL pointer", me ); \ return 1; \ } \ if ( nrrdCheck( nin ) ) { \ biffAddf( NRRD, "%s: problems with given nrrd", me ); \ return 1; \ } \ if ( nrrdTypeBlock == nin->type ) { \ biffAddf( NRRD, "%s: can't resample from type %s", me, \ airEnumStr( nrrdType, nrrdTypeBlock ) ); \ return 1; \ } \ \ rsmc->nin = nin; \ rsmc->flag[flagInput] = AIR_TRUE; \ \ /* per-axis information should be invalidated at this point, because \ if we defer the invalidation to later ...Update( ) calls, it will \ clobber the effects of intervening calls to the likes of \ ...KernelSet( ), ...SampleSet( ), and so on */ \ if ( rsmc->dim != nin->dim ) { \ for ( axIdx=0; axIdx<NRRD_DIM_MAX; axIdx++ ) { \ rsmc->axis[axIdx].center = nrrdCenterUnknown; \ rsmc->axis[axIdx].sizeIn = 0; \ rsmc->axis[axIdx].kernel = NULL; \ rsmc->axis[axIdx].kparm[0] = nrrdDefaultKernelParm0; \ for ( kpIdx=1; kpIdx<NRRD_KERNEL_PARMS_NUM; kpIdx++ ) { \ rsmc->axis[axIdx].kparm[kpIdx] = AIR_NAN; \ } \ rsmc->axis[axIdx].samples = 0; \ rsmc->axis[axIdx].min = AIR_NAN; \ rsmc->axis[axIdx].max = AIR_NAN; \ } \ } \ \ return 0 int nrrdResampleNrrdSet( NrrdResampleContext *rsmc, const Nrrd *nin ) { static const char me[]="nrrdResampleNrrdSet"; NRRD_RESAMPLE_INPUT_SET_BODY; } int nrrdResampleInputSet( NrrdResampleContext *rsmc, const Nrrd *nin ) { static const char me[]="nrrdResampleInputSet"; NRRD_RESAMPLE_INPUT_SET_BODY; } #define PER_AXIS_ERROR_CHECK \ if ( !rsmc ) { \ biffAddf( NRRD, "%s: got NULL pointer", me ); \ return 1; \ } \ if ( !rsmc->nin ) { \ biffAddf( NRRD, "%s: haven't set input nrrd yet", me ); \ return 1; \ } \ if ( !( axIdx < rsmc->nin->dim ) ) { \ biffAddf( NRRD, "%s: axis %u >= nin->dim %u", \ me, axIdx, rsmc->nin->dim ); \ return 1; \ } int nrrdResampleKernelSet( NrrdResampleContext *rsmc, unsigned int axIdx, const NrrdKernel *kernel, double kparm[NRRD_KERNEL_PARMS_NUM] ) { static const char me[]="nrrdResampleKernelSet"; unsigned int kpIdx; PER_AXIS_ERROR_CHECK; rsmc->axis[axIdx].kernel = kernel; if ( kernel ) { for ( kpIdx=0; kpIdx<kernel->numParm; kpIdx++ ) { rsmc->axis[axIdx].kparm[kpIdx] = kparm[kpIdx]; } if ( rsmc->verbose ) { char kstr[AIR_STRLEN_LARGE]; NrrdKernelSpec ksp; nrrdKernelSpecSet( &ksp, rsmc->axis[axIdx].kernel, rsmc->axis[axIdx].kparm ); nrrdKernelSpecSprint( kstr, &ksp ); fprintf( stderr, "%s: axis %u kernel %s\n", me, axIdx, kstr ); } } rsmc->flag[flagKernels] = AIR_TRUE; return 0; } int nrrdResampleSamplesSet( NrrdResampleContext *rsmc, unsigned int axIdx, size_t samples ) { static const char me[]="nrrdResampleSamplesSet"; PER_AXIS_ERROR_CHECK; if ( rsmc->axis[axIdx].samples != samples ) { if ( rsmc->verbose ) { fprintf( stderr, "%s: axis %u samples %u --> %u\n", me, axIdx, AIR_CAST( unsigned int, rsmc->axis[axIdx].samples ), AIR_CAST( unsigned int, samples ) ); } rsmc->axis[axIdx].samples = samples; rsmc->flag[flagSamples] = AIR_TRUE; } return 0; } int nrrdResampleRangeSet( NrrdResampleContext *rsmc, unsigned int axIdx, double min, double max ) { static const char me[]="nrrdResampleRangeSet"; PER_AXIS_ERROR_CHECK; if ( !( AIR_EXISTS( min ) && AIR_EXISTS( max ) && min != max ) ) { biffAddf( NRRD, "%s: need min != max and both to exist", me ); return 1; } if ( !( rsmc->axis[axIdx].min == min && rsmc->axis[axIdx].max == max ) ) { rsmc->axis[axIdx].min = min; rsmc->axis[axIdx].max = max; rsmc->flag[flagRanges] = AIR_TRUE; } return 0; } int nrrdResampleOverrideCenterSet( NrrdResampleContext *rsmc, unsigned int axIdx, int center ) { static const char me[]="nrrdResampleOverrideCenterSet"; PER_AXIS_ERROR_CHECK; if ( center ) { /* we do allow passing nrrdCenterUnknown, to turn off override */ if ( airEnumValCheck( nrrdCenter, center ) ) { biffAddf( NRRD, "%s: didn't get valid centering ( %d )", me, center ); return 1; } } if ( center != rsmc->axis[axIdx].overrideCenter ) { rsmc->axis[axIdx].overrideCenter = center; rsmc->flag[flagOverrideCenters] = AIR_TRUE; } return 0; } void _nrrdResampleMinMaxFull( double *minP, double *maxP, int center, size_t size ) { if ( nrrdCenterCell == center ) { *minP = -0.5; *maxP = size - 0.5; } else { *minP = 0.0; *maxP = size - 1.0; } } int nrrdResampleRangeFullSet( NrrdResampleContext *rsmc, unsigned int axIdx ) { static const char me[]="nrrdResampleRangeFullSet"; double min, max; int center; PER_AXIS_ERROR_CHECK; /* HEY trick is to figure out the axis's centering, and to make sure its the same code as used elsewhere */ center = ( rsmc->axis[axIdx].overrideCenter ? rsmc->axis[axIdx].overrideCenter : ( rsmc->nin->axis[axIdx].center ? rsmc->nin->axis[axIdx].center : rsmc->defaultCenter ) ); _nrrdResampleMinMaxFull( &min, &max, center, rsmc->nin->axis[axIdx].size ); if ( !( rsmc->axis[axIdx].min == min && rsmc->axis[axIdx].max == max ) ) { rsmc->axis[axIdx].min = min; rsmc->axis[axIdx].max = max; rsmc->flag[flagRanges] = AIR_TRUE; } return 0; } int nrrdResampleBoundarySet( NrrdResampleContext *rsmc, int boundary ) { static const char me[]="nrrdResampleBoundarySet"; if ( !rsmc ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( airEnumValCheck( nrrdBoundary, boundary ) ) { biffAddf( NRRD, "%s: invalid boundary %d", me, boundary ); return 1; } if ( rsmc->boundary != boundary ) { rsmc->boundary = boundary; rsmc->flag[flagBoundary] = AIR_TRUE; } return 0; } int nrrdResamplePadValueSet( NrrdResampleContext *rsmc, double padValue ) { static const char me[]="nrrdResamplePadValueSet"; if ( !rsmc ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( rsmc->padValue != padValue ) { rsmc->padValue = padValue; rsmc->flag[flagPadValue] = AIR_TRUE; } return 0; } int nrrdResampleBoundarySpecSet( NrrdResampleContext *rsmc, const NrrdBoundarySpec *bspec ) { static const char me[]="nrrdResampleBoundarySpecSet"; if ( !( rsmc && bspec ) ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( rsmc->boundary != bspec->boundary ) { rsmc->boundary = bspec->boundary; rsmc->flag[flagBoundary] = AIR_TRUE; } if ( rsmc->padValue != bspec->padValue ) { rsmc->padValue = bspec->padValue; rsmc->flag[flagPadValue] = AIR_TRUE; } return 0; } int nrrdResampleRenormalizeSet( NrrdResampleContext *rsmc, int renormalize ) { static const char me[]="nrrdResampleRenormalizeSet"; if ( !rsmc ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( rsmc->renormalize != renormalize ) { rsmc->renormalize = renormalize; rsmc->flag[flagRenormalize] = AIR_TRUE; } return 0; } int nrrdResampleTypeOutSet( NrrdResampleContext *rsmc, int type ) { static const char me[]="nrrdResampleTypeOutSet"; if ( !rsmc ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( nrrdTypeDefault != type && airEnumValCheck( nrrdType, type ) ) { biffAddf( NRRD, "%s: invalid type %d", me, type ); return 1; } if ( nrrdTypeBlock == type ) { biffAddf( NRRD, "%s: can't output %s type", me, airEnumStr( nrrdType, nrrdTypeBlock ) ); return 1; } if ( rsmc->typeOut != type ) { rsmc->typeOut = type; rsmc->flag[flagTypeOut] = AIR_TRUE; } return 0; } int nrrdResampleRoundSet( NrrdResampleContext *rsmc, int roundlast ) { static const char me[]="nrrdResampleRoundSet"; if ( !rsmc ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( rsmc->roundlast != roundlast ) { rsmc->roundlast = roundlast; rsmc->flag[flagRound] = AIR_TRUE; } return 0; } int nrrdResampleClampSet( NrrdResampleContext *rsmc, int clamp ) { static const char me[]="nrrdResampleClampSet"; if ( !rsmc ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( rsmc->clamp != clamp ) { rsmc->clamp = clamp; rsmc->flag[flagClamp] = AIR_TRUE; } return 0; } int _nrrdResampleInputDimensionUpdate( NrrdResampleContext *rsmc ) { if ( rsmc->flag[flagInput] ) { if ( rsmc->dim != rsmc->nin->dim ) { rsmc->dim = rsmc->nin->dim; rsmc->flag[flagInputDimension] = AIR_TRUE; } } return 0; } int _nrrdResampleInputCentersUpdate( NrrdResampleContext *rsmc ) { unsigned int axIdx; int center; if ( rsmc->flag[flagOverrideCenters] || rsmc->flag[flagDefaultCenter] || rsmc->flag[flagInputDimension] || rsmc->flag[flagInput] ) { for ( axIdx=0; axIdx<NRRD_DIM_MAX; axIdx++ ) { center = ( rsmc->axis[axIdx].overrideCenter ? rsmc->axis[axIdx].overrideCenter : ( rsmc->nin->axis[axIdx].center ? rsmc->nin->axis[axIdx].center : rsmc->defaultCenter ) ); if ( rsmc->axis[axIdx].center != center ) { rsmc->axis[axIdx].center = center; rsmc->flag[flagInputCenters] = AIR_TRUE; } } rsmc->flag[flagOverrideCenters] = AIR_FALSE; rsmc->flag[flagDefaultCenter] = AIR_FALSE; } return 0; } int _nrrdResampleInputSizesUpdate( NrrdResampleContext *rsmc ) { unsigned int axIdx; if ( rsmc->flag[flagInputDimension] || rsmc->flag[flagInput] ) { for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { if ( rsmc->axis[axIdx].sizeIn != rsmc->nin->axis[axIdx].size ) { rsmc->axis[axIdx].sizeIn = rsmc->nin->axis[axIdx].size; rsmc->flag[flagInputSizes] = AIR_TRUE; } } rsmc->flag[flagInputDimension] = AIR_FALSE; } return 0; } int _nrrdResampleLineAllocateUpdate( NrrdResampleContext *rsmc ) { static const char me[]="_nrrdResampleLineAllocateUpdate"; unsigned int axIdx; NrrdResampleAxis *axis; if ( rsmc->flag[flagInputSizes] || rsmc->flag[flagKernels] ) { for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { axis = rsmc->axis + axIdx; if ( !axis->kernel ) { nrrdEmpty( axis->nline ); } else { if ( nrrdMaybeAlloc_va( axis->nline, nrrdResample_nt, 1, AIR_CAST( size_t, 1 + axis->sizeIn ) ) ) { biffAddf( NRRD, "%s: couldn't allocate scanline buffer", me ); return 1; } } } rsmc->flag[flagLineAllocate] = AIR_TRUE; } return 0; } int _nrrdResampleVectorAllocateUpdate( NrrdResampleContext *rsmc ) { static const char me[]="_nrrdResampleVectorAllocateUpdate"; unsigned int axIdx, kpIdx, dotLen, minSamples; nrrdResample_t spacingOut, support; NrrdResampleAxis *axis; if ( rsmc->flag[flagKernels] || rsmc->flag[flagSamples] || rsmc->flag[flagRanges] ) { for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { axis = rsmc->axis + axIdx; if ( !axis->kernel ) { /* no resampling on this axis */ continue; } /* check user-set parameters */ if ( !( AIR_EXISTS( axis->min ) && AIR_EXISTS( axis->max ) ) ) { biffAddf( NRRD, "%s: don't have min, max set on axis %u", me, axIdx ); return 1; } for ( kpIdx=0; kpIdx<axis->kernel->numParm; kpIdx++ ) { if ( !AIR_EXISTS( axis->kparm[kpIdx] ) ) { biffAddf( NRRD, "%s: didn't set kernel parm %u on axis %u", me, kpIdx, axIdx ); return 1; } } minSamples = ( nrrdCenterCell == axis->center ? 1 : 2 ); if ( !( axis->samples >= minSamples ) ) { biffAddf( NRRD, "%s: need at least %u output samples ( not %u ) for " "%s-centered sampling along axis %u", me, minSamples, AIR_CAST( unsigned int, axis->samples ), airEnumStr( nrrdCenter, axis->center ), axIdx ); return 1; } /* compute support ( spacingIn == 1.0 by definition ) */ spacingOut = AIR_CAST( nrrdResample_t, ( ( axis->max - axis->min ) / ( nrrdCenterCell == axis->center ? axis->samples : axis->samples - 1 ) ) ); axis->ratio = 1.0/spacingOut; support = AIR_CAST( nrrdResample_t, axis->kernel->support( axis->kparm ) ); if ( axis->ratio > 1 ) { /* if upsampling, we need only as many samples as needed for interpolation with the given kernel */ dotLen = ( int )( 2*ceil( support ) ); } else { /* if downsampling, we need to use all the samples covered by the stretched out version of the kernel */ dotLen = ( int )( 2*ceil( support/axis->ratio ) ); } /* some kernels can report zero support when they're basically delta functions */ dotLen = AIR_MAX( 2, dotLen ); if ( nrrdMaybeAlloc_va( axis->nweight, nrrdResample_nt, 2, AIR_CAST( size_t, dotLen ), AIR_CAST( size_t, axis->samples ) ) || nrrdMaybeAlloc_va( axis->nindex, nrrdTypeInt, 2, AIR_CAST( size_t, dotLen ), AIR_CAST( size_t, axis->samples ) ) ) { biffAddf( NRRD, "%s: trouble allocating index and weighting vectors", me ); return 1; } } rsmc->flag[flagRanges] = AIR_FALSE; rsmc->flag[flagVectorAllocate] = AIR_TRUE; } return 0; } int _nrrdResampleLineFillUpdate( NrrdResampleContext *rsmc ) { unsigned int axIdx; NrrdResampleAxis *axis; nrrdResample_t *line; if ( rsmc->flag[flagPadValue] || rsmc->flag[flagLineAllocate] ) { for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { axis = rsmc->axis + axIdx; if ( axis->kernel ) { line = ( nrrdResample_t* )( axis->nline->data ); line[axis->sizeIn] = AIR_CAST( nrrdResample_t, rsmc->padValue ); } } rsmc->flag[flagPadValue] = AIR_FALSE; rsmc->flag[flagLineAllocate] = AIR_FALSE; rsmc->flag[flagLineFill] = AIR_TRUE; } return 0; } int _nrrdResampleVectorFillUpdate( NrrdResampleContext *rsmc ) { static const char me[]="_nrrdResampleVectorFillUpdate"; unsigned int axIdx, dotIdx, dotLen, halfLen, smpIdx, kpIdx; int *indexData, tmp, base, rawIdx; nrrdResample_t *weightData, idx, integral; NrrdResampleAxis *axis; double kparm[NRRD_KERNEL_PARMS_NUM]; if ( rsmc->flag[flagRenormalize] || rsmc->flag[flagBoundary] || rsmc->flag[flagInputCenters] || rsmc->flag[flagInputSizes] || rsmc->flag[flagVectorAllocate] ) { if ( rsmc->verbose ) { for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { if ( rsmc->axis[axIdx].kernel ) { fprintf( stderr, "%s: axis %u: %s-centering\n", me, axIdx, airEnumStr( nrrdCenter, rsmc->axis[axIdx].center ) ); } } } for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { axis = rsmc->axis + axIdx; if ( !axis->kernel ) { /* no resampling on this axis */ continue; } /* calculate sample locations and do first pass on indices */ indexData = ( int * )axis->nindex->data; weightData = ( nrrdResample_t * )axis->nweight->data; dotLen = AIR_CAST( unsigned int, axis->nweight->axis[0].size ); halfLen = dotLen/2; for ( smpIdx=0; smpIdx<axis->samples; smpIdx++ ) { idx = AIR_CAST( nrrdResample_t, ( nrrdCenterCell == axis->center ? AIR_AFFINE( -0.5, smpIdx, axis->samples-0.5, axis->min, axis->max ) : AIR_AFFINE( 0.0, smpIdx, axis->samples-1.0, axis->min, axis->max ) ) ); base = ( int )floor( idx ) - halfLen + 1; for ( dotIdx=0; dotIdx<dotLen; dotIdx++ ) { tmp = indexData[dotIdx + dotLen*smpIdx] = base + dotIdx; weightData[dotIdx + dotLen*smpIdx] = idx - tmp; } if ( rsmc->verbose ) { if ( !smpIdx ) { fprintf( stderr, "%s: smpIdx=%u -> idx=%g -> base=%d\n", me, smpIdx, idx, base ); fprintf( stderr, "%s: sample locations:\n", me ); } fprintf( stderr, "%s: %d ( sample locations )\n ", me, smpIdx ); for ( dotIdx=0; dotIdx<dotLen; dotIdx++ ) { fprintf( stderr, "%d/%g ", indexData[dotIdx + dotLen*smpIdx], weightData[dotIdx + dotLen*smpIdx] ); } fprintf( stderr, "\n" ); } } /* figure out what to do with the out-of-range indices */ for ( dotIdx=0; dotIdx<dotLen*axis->samples; dotIdx++ ) { rawIdx = indexData[dotIdx]; if ( !AIR_IN_CL( 0, rawIdx, AIR_CAST( int, axis->sizeIn )-1 ) ) { switch( rsmc->boundary ) { case nrrdBoundaryPad: case nrrdBoundaryWeight: /* this will be further handled later */ rawIdx = AIR_CAST( int, axis->sizeIn ); break; case nrrdBoundaryBleed: rawIdx = AIR_CLAMP( 0, rawIdx, AIR_CAST( int, axis->sizeIn )-1 ); break; case nrrdBoundaryWrap: rawIdx = AIR_MOD( rawIdx, AIR_CAST( int, axis->sizeIn ) ); break; case nrrdBoundaryMirror: rawIdx = _nrrdMirror_32( AIR_CAST( unsigned int, axis->sizeIn ), rawIdx ); break; default: biffAddf( NRRD, "%s: boundary behavior %d unknown/unimplemented", me, rsmc->boundary ); return 0; } indexData[dotIdx] = rawIdx; } } /* Wow - there is a big rift here between old conventions for how NrrdKernels were defined, versus the newer practice of creating parameter-free kernels. The "sneaky trick" code below for changing parm[0] only works if the kernel actually looks at parm[0]! So at least for the parameter-free kernels ( and maybe other kernels, but HEY there's no principled way of knowing! ) we have to do what we probably should have been done all along: simulating the kernel scaling by pre-processing the evaluation locations and post-processing the kernel weights */ if ( 0 == axis->kernel->numParm ) { size_t nn, ii; double ratio; nn = dotLen*axis->samples; ratio = axis->ratio; if ( ratio < 1 ) { for ( ii=0; ii<nn; ii++ ) { weightData[ii] *= ratio; } } axis->kernel->EVALN( weightData, weightData, nn, axis->kparm ); if ( ratio < 1 ) { for ( ii=0; ii<nn; ii++ ) { weightData[ii] *= ratio; } } } else { /* run the sample locations through the chosen kernel. We play a sneaky trick on the kernel parameter 0 in case of downsampling to create the blurring of the old index space */ kparm[0] = ( axis->ratio < 1 ? axis->kparm[0] / axis->ratio : axis->kparm[0] ); for ( kpIdx=1; kpIdx<NRRD_KERNEL_PARMS_NUM; kpIdx++ ) { kparm[kpIdx] = axis->kparm[kpIdx]; } axis->kernel->EVALN( weightData, weightData, dotLen*axis->samples, kparm ); /* special handling of "cheap" kernel */ if ( nrrdKernelCheap == axis->kernel ) { for ( smpIdx=0; smpIdx<axis->samples; smpIdx++ ) { nrrdResample_t dist, minDist; int minIdx, minSet; minIdx = indexData[0 + dotLen*smpIdx]; minDist = weightData[0 + dotLen*smpIdx]; /* find sample closest to origin */ for ( dotIdx=1; dotIdx<dotLen; dotIdx++ ) { dist = weightData[dotIdx + dotLen*smpIdx]; if ( dist < minDist ) { minDist = dist; minIdx = indexData[dotIdx + dotLen*smpIdx]; } } /* set kernel weights to select sample closest to origin */ minSet = AIR_FALSE; for ( dotIdx=0; dotIdx<dotLen; dotIdx++ ) { if ( minIdx == indexData[dotIdx + dotLen*smpIdx] && !minSet ) { weightData[dotIdx + dotLen*smpIdx] = 1.0; minSet = AIR_TRUE; } else { weightData[dotIdx + dotLen*smpIdx] = 0.0; } } } } } if ( rsmc->verbose ) { fprintf( stderr, "%s: axis %u sample weights:\n", me, axIdx ); for ( smpIdx=0; smpIdx<axis->samples; smpIdx++ ) { fprintf( stderr, "%s: %d ( sample weights )\n ", me, smpIdx ); for ( dotIdx=0; dotIdx<dotLen; dotIdx++ ) { fprintf( stderr, "%d/%g ", indexData[dotIdx + dotLen*smpIdx], weightData[dotIdx + dotLen*smpIdx] ); } fprintf( stderr, "\n" ); } } /* final fixes on weighting values */ integral = AIR_CAST( nrrdResample_t, axis->kernel->integral( axis->kparm ) ); if ( nrrdBoundaryWeight == rsmc->boundary ) { if ( integral ) { /* above, we set to axis->sizeIn all the indices that were out of range. We now use that to determine the sum of the weights for the indices that were in-range */ for ( smpIdx=0; smpIdx<axis->samples; smpIdx++ ) { nrrdResample_t wght = 0; for ( dotIdx=0; dotIdx<dotLen; dotIdx++ ) { if ( AIR_CAST( int, axis->sizeIn ) != indexData[dotIdx + dotLen*smpIdx] ) { wght += weightData[dotIdx + dotLen*smpIdx]; } } for ( dotIdx=0; dotIdx<dotLen; dotIdx++ ) { if ( AIR_CAST( int, axis->sizeIn ) != indexData[dotIdx + dotLen*smpIdx] ) { weightData[dotIdx + dotLen*smpIdx] *= integral/wght; } else { weightData[dotIdx + dotLen*smpIdx] = 0; } } } } } else { /* try to remove ripple/grating on downsampling, and errors in weighting on upsampling when using kernels that are not first-order accurate */ if ( rsmc->renormalize && integral ) { for ( smpIdx=0; smpIdx<axis->samples; smpIdx++ ) { nrrdResample_t wght = 0; for ( dotIdx=0; dotIdx<dotLen; dotIdx++ ) { wght += weightData[dotIdx + dotLen*smpIdx]; } if ( wght ) { for ( dotIdx=0; dotIdx<dotLen; dotIdx++ ) { /* this used to normalize the weights so that they summed to integral ( "*= integral/wght" ), which meant that if you use a very truncated Gaussian, then your over-all image brightness goes down. This seems very contrary to the whole point of renormalization. */ weightData[dotIdx + dotLen*smpIdx] *= AIR_CAST( nrrdResample_t, 1.0/wght ); } } } } } if ( rsmc->verbose ) { fprintf( stderr, "%s: axis %u post-correction sample weights:\n", me, axIdx ); for ( smpIdx=0; smpIdx<axis->samples; smpIdx++ ) { fprintf( stderr, "%s: %d ( sample weights )\n ", me, smpIdx ); for ( dotIdx=0; dotIdx<dotLen; dotIdx++ ) { fprintf( stderr, "%d/%g ", indexData[dotIdx + dotLen*smpIdx], weightData[dotIdx + dotLen*smpIdx] ); } fprintf( stderr, "\n" ); } } } rsmc->flag[flagRenormalize] = AIR_FALSE; rsmc->flag[flagBoundary] = AIR_FALSE; rsmc->flag[flagInputCenters] = AIR_FALSE; rsmc->flag[flagVectorAllocate] = AIR_FALSE; rsmc->flag[flagVectorFill] = AIR_TRUE; } return 0; } int _nrrdResamplePermutationUpdate( NrrdResampleContext *rsmc ) { static const char me[]="_nrrdResamplePermutationUpdate"; unsigned int axIdx, passIdx, currTop, lastTop, fromTop, toTop; int bi; if ( rsmc->flag[flagInputSizes] || rsmc->flag[flagKernels] || rsmc->flag[flagSamples] ) { rsmc->topRax = rsmc->botRax = AIR_CAST( unsigned int, -1 ); for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { if ( rsmc->axis[axIdx].kernel ) { if ( AIR_CAST( unsigned int, -1 ) == rsmc->topRax ) { rsmc->topRax = axIdx; } rsmc->botRax = axIdx; } } if ( rsmc->verbose ) { fprintf( stderr, "%s: topRax = %u ( %d ); botRax = %u ( %d )\n", me, rsmc->topRax, AIR_CAST( int, rsmc->topRax ), rsmc->botRax, AIR_CAST( int, rsmc->botRax ) ); } /* figure out total number of passes needed, and construct the permute[] array. permute[i] = j means that the axis in position i of the old array will be in position j of the new one ( permute[] answers "where do I put this", not "what got put here" ). */ rsmc->passNum = 0; bi = 0; for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { if ( rsmc->axis[axIdx].kernel ) { do { bi = AIR_MOD( bi+1, AIR_CAST( int, rsmc->dim ) ); } while ( !rsmc->axis[bi].kernel ); rsmc->permute[bi] = axIdx; rsmc->passNum += 1; } else { rsmc->permute[axIdx] = axIdx; bi += bi == AIR_CAST( int, axIdx ); } } rsmc->permute[rsmc->dim] = rsmc->dim; /* HEY: what is this for? */ if ( rsmc->passNum ) { toTop = AIR_CAST( unsigned int, -1 ); for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { /* this will always "break" somewhere */ if ( rsmc->topRax == rsmc->permute[axIdx] ) { toTop = axIdx; break; } } fromTop = rsmc->permute[rsmc->topRax]; if ( rsmc->verbose ) { fprintf( stderr, "%s: passNum = %u; permute =\n ", me, rsmc->passNum ); for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { fprintf( stderr, "%u ", rsmc->permute[axIdx] ); } fprintf( stderr, "\n" ); fprintf( stderr, "%s: toTop = %u; fromTop = %u\n", me, toTop, fromTop ); } /* create array of how the axes will be arranged in each pass ( "ax" ), and create array of how big each axes is in each pass ( "sz" ). The input to pass i will have axis layout described in ax[i] and axis sizes described in sz[i] */ passIdx = 0; currTop = rsmc->topRax; rsmc->passAxis[passIdx] = currTop; rsmc->axis[currTop].passIdx = passIdx; for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { rsmc->axis[currTop].axisPerm[axIdx] = axIdx; rsmc->axis[currTop].sizePerm[axIdx] = rsmc->axis[axIdx].sizeIn; } for ( passIdx=1; passIdx<rsmc->passNum+1; passIdx++ ) { lastTop = currTop; currTop = ( passIdx<rsmc->passNum ? rsmc->axis[currTop].axisPerm[toTop] : NRRD_DIM_MAX ); rsmc->passAxis[passIdx] = currTop; rsmc->axis[currTop].passIdx = passIdx; for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { rsmc->axis[currTop].axisPerm[rsmc->permute[axIdx]] = rsmc->axis[lastTop].axisPerm[axIdx]; rsmc->axis[currTop].sizePerm[rsmc->permute[axIdx]] = rsmc->axis[lastTop].sizePerm[axIdx]; /* modify the one size corresponding to the resampled axis */ rsmc->axis[currTop].sizePerm[fromTop] = rsmc->axis[lastTop].samples; } } if ( rsmc->verbose ) { NrrdResampleAxis *axis; fprintf( stderr, "%s: axis and size permutations:\n", me ); for ( passIdx=0; passIdx<rsmc->passNum+1; passIdx++ ) { axis = rsmc->axis + rsmc->passAxis[passIdx]; fprintf( stderr, "----- pass[%u=?=%u] @ %u %s:\n", passIdx, axis->passIdx, rsmc->passAxis[passIdx], ( passIdx<rsmc->passNum ? "" : "( output of final pass )" ) ); if ( !passIdx ) { fprintf( stderr, "resampling: " ); for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { fprintf( stderr, "%s ", rsmc->axis[axIdx].kernel ? " XX" : " " ); } fprintf( stderr, "\n" ); } fprintf( stderr, " axes: " ); for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { fprintf( stderr, "%3u ", axis->axisPerm[axIdx] ); } fprintf( stderr, "\n" ); fprintf( stderr, " sizes: " ); for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { fprintf( stderr, "%3u ", AIR_CAST( unsigned int, axis->sizePerm[axIdx] ) ); } fprintf( stderr, "\n" ); } fprintf( stderr, "\n" ); } } rsmc->flag[flagInputSizes] = AIR_FALSE; rsmc->flag[flagKernels] = AIR_FALSE; rsmc->flag[flagSamples] = AIR_FALSE; rsmc->flag[flagPermutation] = AIR_TRUE; } return 0; } /* Copy input to output, but with the optional clamping and rounding */ int _nrrdResampleTrivial( NrrdResampleContext *rsmc, Nrrd *nout, int typeOut, int doRound, nrrdResample_t ( *lup )( const void *, size_t ), nrrdResample_t ( *clamp )( nrrdResample_t ), nrrdResample_t ( *ins )( void *, size_t, nrrdResample_t ) ) { static const char me[]="_nrrdResampleTrivial"; size_t size[NRRD_DIM_MAX], valNum, valIdx; nrrdResample_t val; const void *dataIn; void *dataOut; nrrdAxisInfoGet_nva( rsmc->nin, nrrdAxisInfoSize, size ); if ( nrrdMaybeAlloc_nva( nout, typeOut, rsmc->nin->dim, size ) ) { biffAddf( NRRD, "%s: couldn't allocate output", me ); return 1; } valNum = nrrdElementNumber( rsmc->nin ); dataIn = rsmc->nin->data; dataOut = nout->data; for ( valIdx=0; valIdx<valNum; valIdx++ ) { val = lup( dataIn, valIdx ); if ( doRound ) { val = AIR_CAST( nrrdResample_t, AIR_ROUNDUP( val ) ); } if ( rsmc->clamp ) { val = clamp( val ); } ins( dataOut, valIdx, val ); } return 0; } int _nrrdResampleCore( NrrdResampleContext *rsmc, Nrrd *nout, int typeOut, int doRound, nrrdResample_t ( *lup )( const void *, size_t ), nrrdResample_t ( *clamp )( nrrdResample_t ), nrrdResample_t ( *ins )( void *, size_t, nrrdResample_t ) ) { static const char me[]="_nrrdResampleCore"; unsigned int axIdx, passIdx; size_t strideIn, strideOut, lineNum, lineIdx, coordIn[NRRD_DIM_MAX], coordOut[NRRD_DIM_MAX]; nrrdResample_t *line, *weight, *rsmpIn, *rsmpOut; int *indx; const void *dataIn; void *dataOut; NrrdResampleAxis *axisIn, *axisOut; airArray *mop; /* NOTE: there was an odd memory leak here with normal operation ( no errors ), because the final airMopOkay( ) was missing, but quick attempts at resolving it pre-Teem-1.9 release were not successful ( surprisingly, commenting out the airMopSub's led to a segfault ). So, the airMopAdd which is supposed to manage the per-axis resampling result is commented out, and there are no leaks and no segfaults with normal operation, which is good enough for now */ /* compute strideIn; this is constant across passes because all passes resample topRax, and axes with lower indices have constant length. */ strideIn = 1; for ( axIdx=0; axIdx<rsmc->topRax; axIdx++ ) { strideIn *= rsmc->axis[axIdx].sizeIn; } mop = airMopNew( ); for ( passIdx=0; passIdx<rsmc->passNum; passIdx++ ) { if ( rsmc->verbose ) { fprintf( stderr, "%s: -------------- pass %u/%u \n", me, passIdx, rsmc->passNum ); } /* calculate pass-specific size, stride, and number info */ axisIn = rsmc->axis + rsmc->passAxis[passIdx]; axisOut = rsmc->axis + rsmc->passAxis[passIdx+1]; lineNum = strideOut = 1; for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { if ( axIdx < rsmc->botRax ) { strideOut *= axisOut->sizePerm[axIdx]; } if ( axIdx != rsmc->topRax ) { lineNum *= axisIn->sizePerm[axIdx]; } } if ( rsmc->verbose ) { char stmp1[AIR_STRLEN_SMALL], stmp2[AIR_STRLEN_SMALL]; fprintf( stderr, "%s( %u ): lineNum = %s\n", me, passIdx, airSprintSize_t( stmp1, lineNum ) ); fprintf( stderr, "%s( %u ): strideIn = %s, strideOut = %s\n", me, passIdx, airSprintSize_t( stmp1, strideIn ), airSprintSize_t( stmp2, strideOut ) ); } /* allocate output for this pass */ if ( passIdx < rsmc->passNum-1 ) { axisOut->nrsmp = nrrdNew( ); /* see NOTE above! airMopAdd( mop, axisOut->nrsmp, ( airMopper )nrrdNuke, airMopAlways ); */ if ( nrrdMaybeAlloc_nva( axisOut->nrsmp, nrrdResample_nt, rsmc->dim, axisOut->sizePerm ) ) { biffAddf( NRRD, "%s: trouble allocating output of pass %u", me, passIdx ); airMopError( mop ); return 1; } if ( rsmc->verbose ) { fprintf( stderr, "%s: allocated pass %u/%u output nrrd @ %p/%p " "( on axis %u )\n", me, passIdx, axisIn->passIdx, AIR_CAST( void*, axisOut->nrsmp ), AIR_CAST( void*, axisOut->nrsmp->data ), axisOut->axIdx ); } } else { if ( nrrdMaybeAlloc_nva( nout, typeOut, rsmc->dim, axisOut->sizePerm ) ) { biffAddf( NRRD, "%s: trouble allocating final output", me ); airMopError( mop ); return 1; } if ( rsmc->verbose ) { fprintf( stderr, "%s: allocated final pass %u output nrrd @ %p/%p\n", me, passIdx, AIR_CAST( void*, nout ), AIR_CAST( void*, nout->data ) ); } } /* set up data pointers */ if ( 0 == passIdx ) { rsmpIn = NULL; dataIn = rsmc->nin->data; } else { rsmpIn = ( nrrdResample_t * )( axisIn->nrsmp->data ); dataIn = NULL; } if ( passIdx < rsmc->passNum-1 ) { rsmpOut = ( nrrdResample_t * )( axisOut->nrsmp->data ); dataOut = NULL; } else { rsmpOut = NULL; dataOut = nout->data; } line = ( nrrdResample_t * )( axisIn->nline->data ); indx = ( int * )( axisIn->nindex->data ); weight = ( nrrdResample_t * )( axisIn->nweight->data ); if ( rsmc->verbose ) { fprintf( stderr, "%s: {rsmp, data}In = %p/%p; {rsmp, data}Out = %p/%p\n", me, rsmpIn, dataIn, rsmpOut, dataOut ); fprintf( stderr, "%s: line = %p; indx = %p; weight = %p\n", me, line, indx, weight ); } /* the skinny */ for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { coordIn[axIdx] = 0; coordOut[axIdx] = 0; } for ( lineIdx=0; lineIdx<lineNum; lineIdx++ ) { size_t smpIdx, dotIdx, dotLen, indexIn, indexOut; /* calculate the ( linear ) indices of the beginnings of the input and output scanlines */ NRRD_INDEX_GEN( indexIn, coordIn, axisIn->sizePerm, rsmc->dim ); NRRD_INDEX_GEN( indexOut, coordOut, axisOut->sizePerm, rsmc->dim ); /* read input scanline into scanline buffer */ if ( 0 == passIdx ) { for ( smpIdx=0; smpIdx<axisIn->sizeIn; smpIdx++ ) { line[smpIdx] = lup( dataIn, smpIdx*strideIn + indexIn ); } } else { for ( smpIdx=0; smpIdx<axisIn->sizeIn; smpIdx++ ) { line[smpIdx] = rsmpIn[smpIdx*strideIn + indexIn]; } } /* do the bloody convolution and save the output value */ dotLen = axisIn->nweight->axis[0].size; for ( smpIdx=0; smpIdx<axisIn->samples; smpIdx++ ) { double val; val = 0.0; if ( nrrdResampleNonExistentNoop != rsmc->nonExistent ) { double wsum; wsum = 0.0; for ( dotIdx=0; dotIdx<dotLen; dotIdx++ ) { double tmpV, tmpW; tmpV = line[indx[dotIdx + dotLen*smpIdx]]; if ( AIR_EXISTS( tmpV ) ) { tmpW = weight[dotIdx + dotLen*smpIdx]; val += tmpV*tmpW; wsum += tmpW; } } if ( wsum ) { if ( nrrdResampleNonExistentRenormalize == rsmc->nonExistent ) { val /= wsum; } /* else nrrdResampleNonExistentWeight: leave as is */ } else { val = AIR_NAN; } } else { /* nrrdResampleNonExistentNoop: do convolution sum w/out worries about value existance */ for ( dotIdx=0; dotIdx<dotLen; dotIdx++ ) { val += ( line[indx[dotIdx + dotLen*smpIdx]] * weight[dotIdx + dotLen*smpIdx] ); } } if ( passIdx < rsmc->passNum-1 ) { rsmpOut[smpIdx*strideOut + indexOut] = val; } else { if ( doRound ) { val = AIR_CAST( nrrdResample_t, AIR_ROUNDUP( val ) ); } if ( rsmc->clamp ) { val = clamp( val ); } ins( dataOut, smpIdx*strideOut + indexOut, val ); } } /* as long as there's another line to be processed, increment the coordinates for the scanline starts. We don't use the usual NRRD_COORD macros because we're subject to the unusual constraint that coordIn[topRax] and coordOut[permute[topRax]] must stay == 0 */ if ( lineIdx < lineNum-1 ) { axIdx = rsmc->topRax ? 0 : 1; coordIn[axIdx]++; coordOut[rsmc->permute[axIdx]]++; while ( coordIn[axIdx] == axisIn->sizePerm[axIdx] ) { coordIn[axIdx] = coordOut[rsmc->permute[axIdx]] = 0; axIdx++; axIdx += axIdx == rsmc->topRax; coordIn[axIdx]++; coordOut[rsmc->permute[axIdx]]++; } } } /* ( maybe ) free input to this pass, now that we're done with it */ if ( axisIn->nrsmp ) { if ( rsmc->verbose ) { fprintf( stderr, "%s: nrrdNuke( %p ) pass %u input ( on axis %u )\n", me, AIR_CAST( void*, axisIn->nrsmp ), axisIn->passIdx, axisIn->axIdx ); } axisIn->nrsmp = nrrdNuke( axisIn->nrsmp ); /* airMopSub( mop, axisIn->nrsmp, ( airMopper )nrrdNuke ); */ } } /* for passIdx */ airMopOkay( mop ); return 0; } int _nrrdResampleOutputUpdate( NrrdResampleContext *rsmc, Nrrd *nout, const char *func ) { static const char me[]="_nrrdResampleOutputUpdate"; #if NRRD_RESAMPLE_FLOAT float ( *lup )( const void *, size_t ), ( *clamp )( float ), ( *ins )( void *, size_t, float ); #else double ( *lup )( const void *, size_t ), ( *clamp )( double ), ( *ins )( void *, size_t, double ); #endif unsigned int axIdx; int typeOut, doRound; if ( rsmc->flag[flagClamp] || rsmc->flag[flagNonExistent] || rsmc->flag[flagRound] || rsmc->flag[flagTypeOut] || rsmc->flag[flagLineFill] || rsmc->flag[flagVectorFill] || rsmc->flag[flagPermutation] || rsmc->flag[flagInput] ) { typeOut = ( nrrdTypeDefault == rsmc->typeOut ? rsmc->nin->type : rsmc->typeOut ); doRound = rsmc->roundlast && nrrdTypeIsIntegral[typeOut]; if ( doRound && ( nrrdTypeInt == typeOut || nrrdTypeUInt == typeOut || nrrdTypeLLong == typeOut || nrrdTypeULLong == typeOut ) ) { fprintf( stderr, "%s: WARNING: possible erroneous output with " "rounding of %s output type due to int-based implementation " "of rounding\n", me, airEnumStr( nrrdType, typeOut ) ); } #if NRRD_RESAMPLE_FLOAT lup = nrrdFLookup[rsmc->nin->type]; clamp = nrrdFClamp[typeOut]; ins = nrrdFInsert[typeOut]; #else lup = nrrdDLookup[rsmc->nin->type]; clamp = nrrdDClamp[typeOut]; ins = nrrdDInsert[typeOut]; #endif if ( 0 == rsmc->passNum ) { if ( _nrrdResampleTrivial( rsmc, nout, typeOut, doRound, lup, clamp, ins ) ) { biffAddf( NRRD, "%s: trouble", me ); return 1; } } else { if ( _nrrdResampleCore( rsmc, nout, typeOut, doRound, lup, clamp, ins ) ) { biffAddf( NRRD, "%s: trouble", me ); return 1; } } /* HEY: need to create textual representation of resampling parameters */ if ( nrrdContentSet_va( nout, func, rsmc->nin, "" ) ) { biffAddf( NRRD, "%s:", me ); return 1; } /* start work of updating space origin */ nrrdSpaceVecCopy( nout->spaceOrigin, rsmc->nin->spaceOrigin ); for ( axIdx=0; axIdx<rsmc->dim; axIdx++ ) { if ( rsmc->axis[axIdx].kernel ) { /* this axis was resampled */ double minIdxFull, maxIdxFull, zeroPos; /* actually its in continuous index space ... */ _nrrdAxisInfoCopy( nout->axis + axIdx, rsmc->nin->axis + axIdx, ( NRRD_AXIS_INFO_SIZE_BIT | NRRD_AXIS_INFO_SPACING_BIT | NRRD_AXIS_INFO_THICKNESS_BIT | NRRD_AXIS_INFO_MIN_BIT | NRRD_AXIS_INFO_MAX_BIT | NRRD_AXIS_INFO_SPACEDIRECTION_BIT | NRRD_AXIS_INFO_CENTER_BIT | NRRD_AXIS_INFO_KIND_BIT ) ); /* now set all the per-axis fields we just abstained from copying */ /* size was already set */ nout->axis[axIdx].spacing = ( rsmc->nin->axis[axIdx].spacing / rsmc->axis[axIdx].ratio ); /* for now, we don't attempt to modify thickness */ nout->axis[axIdx].thickness = AIR_NAN; /* We had to assume a specific centering when doing resampling */ nout->axis[axIdx].center = rsmc->axis[axIdx].center; _nrrdResampleMinMaxFull( &minIdxFull, &maxIdxFull, rsmc->axis[axIdx].center, rsmc->nin->axis[axIdx].size ); nout->axis[axIdx].min = AIR_AFFINE( minIdxFull, rsmc->axis[axIdx].min, maxIdxFull, rsmc->nin->axis[axIdx].min, rsmc->nin->axis[axIdx].max ); nout->axis[axIdx].max = AIR_AFFINE( minIdxFull, rsmc->axis[axIdx].max, maxIdxFull, rsmc->nin->axis[axIdx].min, rsmc->nin->axis[axIdx].max ); nrrdSpaceVecScale( nout->axis[axIdx].spaceDirection, 1.0/rsmc->axis[axIdx].ratio, rsmc->nin->axis[axIdx].spaceDirection ); nout->axis[axIdx].kind = _nrrdKindAltered( rsmc->nin->axis[axIdx].kind, AIR_TRUE ); /* space origin may have translated along this axis; only do this if the axis was already spatial */ if ( AIR_EXISTS( rsmc->nin->axis[axIdx].spaceDirection[0] ) ) { zeroPos = NRRD_POS( nout->axis[axIdx].center, rsmc->axis[axIdx].min, rsmc->axis[axIdx].max, rsmc->axis[axIdx].samples, 0 ); nrrdSpaceVecScaleAdd2( nout->spaceOrigin, 1.0, nout->spaceOrigin, zeroPos, rsmc->nin->axis[axIdx].spaceDirection ); } } else { /* no resampling; this axis totally unchanged */ _nrrdAxisInfoCopy( nout->axis + axIdx, rsmc->nin->axis + axIdx, NRRD_AXIS_INFO_NONE ); /* also: the space origin has not translated along this axis */ } } if ( nrrdBasicInfoCopy( nout, rsmc->nin, NRRD_BASIC_INFO_DATA_BIT | NRRD_BASIC_INFO_TYPE_BIT | NRRD_BASIC_INFO_BLOCKSIZE_BIT | NRRD_BASIC_INFO_DIMENSION_BIT | NRRD_BASIC_INFO_SPACEORIGIN_BIT | NRRD_BASIC_INFO_CONTENT_BIT | NRRD_BASIC_INFO_COMMENTS_BIT | ( nrrdStateKeyValuePairsPropagate ? 0 : NRRD_BASIC_INFO_KEYVALUEPAIRS_BIT ) ) ) { biffAddf( NRRD, "%s:", me ); return 1; } rsmc->flag[flagClamp] = AIR_FALSE; rsmc->flag[flagNonExistent] = AIR_FALSE; rsmc->flag[flagRound] = AIR_FALSE; rsmc->flag[flagTypeOut] = AIR_FALSE; rsmc->flag[flagLineFill] = AIR_FALSE; rsmc->flag[flagVectorFill] = AIR_FALSE; rsmc->flag[flagPermutation] = AIR_FALSE; rsmc->flag[flagInput] = AIR_FALSE; } return 0; } int nrrdResampleExecute( NrrdResampleContext *rsmc, Nrrd *nout ) { static const char me[]="nrrdResampleExecute", func[]="resample"; double time0; if ( !( rsmc && nout ) ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } /* any other error checking? Do we need a _nrrdResampleContextCheck( ) ? */ if ( nrrdBoundaryPad == rsmc->boundary && !AIR_EXISTS( rsmc->padValue ) ) { biffAddf( NRRD, "%s: asked for boundary padding, " "but no pad value set", me ); return 1; } time0 = airTime( ); if ( _nrrdResampleInputDimensionUpdate( rsmc ) || _nrrdResampleInputCentersUpdate( rsmc ) || _nrrdResampleInputSizesUpdate( rsmc ) || _nrrdResampleLineAllocateUpdate( rsmc ) || _nrrdResampleVectorAllocateUpdate( rsmc ) || _nrrdResampleLineFillUpdate( rsmc ) || _nrrdResampleVectorFillUpdate( rsmc ) || _nrrdResamplePermutationUpdate( rsmc ) || _nrrdResampleOutputUpdate( rsmc, nout, func ) ) { biffAddf( NRRD, "%s: trouble resampling", me ); return 1; } rsmc->time = airTime( ) - time0; return 0; }

/Users/scm/git/github/teem/src/nrrd/resampleNrrd.c

/Users/scm/git/github/teem/src/nrrd/simple.c

1 /* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2015, 2014, 2013, 2012, 2011, 2010, 2009 University of Chicago Copyright ( C ) 2008, 2007, 2006, 2005 Gordon Kindlmann Copyright ( C ) 2004, 2003, 2002, 2001, 2000, 1999, 1998 University of Utah This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "nrrd.h" #include "privateNrrd.h" #include <limits.h> /* The "/ *Teem:" ( without space ) comments in here are an experiment */ const char * nrrdBiffKey = "nrrd"; /* ******** nrrdSpaceDimension ** ** returns expected dimension of given space ( from nrrdSpace* enum ), or, ** 0 if there is no expected dimension. ** ** The expected behavior here is to return 0 for nrrdSpaceUnknown, because ** that is the right answer, not because its an error of any kind. */ unsigned int 44 nrrdSpaceDimension( int space ) { static const char me[]="nrrdSpaceDimension"; unsigned int ret; if ( !( AIR_IN_OP( nrrdSpaceUnknown, space, nrrdSpaceLast ) ) ) { /* they gave us invalid or unknown space */ return 0; } switch ( space ) { case nrrdSpaceRightUp: case nrrdSpaceRightDown: ret = 2; break; case nrrdSpaceRightAnteriorSuperior: case nrrdSpaceLeftAnteriorSuperior: case nrrdSpaceLeftPosteriorSuperior: case nrrdSpaceScannerXYZ: case nrrdSpace3DRightHanded: case nrrdSpace3DLeftHanded: ret = 3; break; case nrrdSpaceRightAnteriorSuperiorTime: case nrrdSpaceLeftAnteriorSuperiorTime: case nrrdSpaceLeftPosteriorSuperiorTime: case nrrdSpaceScannerXYZTime: case nrrdSpace3DRightHandedTime: case nrrdSpace3DLeftHandedTime: ret = 4; break; default: fprintf( stderr, "%s: PANIC: nrrdSpace %d not implemented!\n", me, space ); ret = UINT_MAX; /* exit( 1 ); */ break; } return ret; } /* ******** nrrdSpaceSet ** ** What to use to set space, when a value from nrrdSpace enum is known, ** or, to nullify all space-related information when passed nrrdSpaceUnknown */ int 88 nrrdSpaceSet( Nrrd *nrrd, int space ) { static const char me[]="nrrdSpaceSet"; unsigned axi, saxi; if ( !nrrd ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( nrrdSpaceUnknown == space ) { nrrd->space = nrrdSpaceUnknown; nrrd->spaceDim = 0; for ( axi=0; axi<NRRD_DIM_MAX; axi++ ) { nrrdSpaceVecSetNaN( nrrd->axis[axi].spaceDirection ); } for ( saxi=0; saxi<NRRD_SPACE_DIM_MAX; saxi++ ) { airFree( nrrd->spaceUnits[saxi] ); nrrd->spaceUnits[saxi] = NULL; } nrrdSpaceVecSetNaN( nrrd->spaceOrigin ); } else { if ( airEnumValCheck( nrrdSpace, space ) ) { biffAddf( NRRD, "%s: given space ( %d ) not valid", me, space ); return 1; } nrrd->space = space; nrrd->spaceDim = nrrdSpaceDimension( space ); } return 0; } /* ******** nrrdSpaceDimensionSet ** ** What to use to set space, based on spaceDim alone ( nrrd->space set to ** nrrdSpaceUnknown ) */ int 125 nrrdSpaceDimensionSet( Nrrd *nrrd, unsigned int spaceDim ) { static const char me[]="nrrdSpaceDimensionSet"; if ( !nrrd ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( !( spaceDim <= NRRD_SPACE_DIM_MAX ) ) { biffAddf( NRRD, "%s: given spaceDim ( %u ) not valid", me, spaceDim ); return 1; } nrrd->space = nrrdSpaceUnknown; nrrd->spaceDim = spaceDim; return 0; } /* ******** nrrdSpaceOriginGet ** ** retrieves the spaceOrigin from given nrrd, and returns spaceDim ** Indices 0 through spaceDim-1 are set in given vector[] to coords ** of space origin, and all further indices are set to NaN. That is, ** this really does write to all NRRD_SPACE_DIM_MAX elements of vector[] */ unsigned int 150 nrrdSpaceOriginGet( const Nrrd *nrrd, double vector[NRRD_SPACE_DIM_MAX] ) { unsigned int sdi, ret; if ( nrrd && vector ) { for ( sdi=0; sdi<nrrd->spaceDim; sdi++ ) { vector[sdi] = nrrd->spaceOrigin[sdi]; } for ( sdi=nrrd->spaceDim; sdi<NRRD_SPACE_DIM_MAX; sdi++ ) { vector[sdi] = AIR_NAN; } ret = nrrd->spaceDim; } else { ret = 0; } return ret; } /* ******** nrrdSpaceOriginSet ** ** convenience function for setting spaceOrigin. ** Note: space ( or spaceDim ) must be already set. ** The given "vector" is only read for spaceDim elements ** ** returns 1 if there were problems, 0 otherwise */ int 178 nrrdSpaceOriginSet( Nrrd *nrrd, const double *vector ) { static const char me[]="nrrdSpaceOriginSet"; unsigned int sdi; if ( !( nrrd && vector ) ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( !( 0 < nrrd->spaceDim && nrrd->spaceDim <= NRRD_SPACE_DIM_MAX ) ) { biffAddf( NRRD, "%s: set spaceDim %d not valid", me, nrrd->spaceDim ); return 1; } for ( sdi=0; sdi<nrrd->spaceDim; sdi++ ) { nrrd->spaceOrigin[sdi] = vector[sdi]; } for ( sdi=nrrd->spaceDim; sdi<NRRD_SPACE_DIM_MAX; sdi++ ) { nrrd->spaceOrigin[sdi] = AIR_NAN; } return 0; } /* ******** nrrdOriginCalculate ** ** makes an effort to calculate something like an "origin" ( as in ** nrrd->spaceOrigin ) from the per-axis min, max, or spacing, when ** there is no real space information. Like the spaceOrigin, this ** location is supposed to be THE CENTER of the first sample. To ** avoid making assumptions about the nrrd or the caller, a default ** sample centering ( defaultCenter ) has to be provided ( use either ** nrrdCenterNode or nrrdCenterCell ). The axes that are used ** for the origin calculation have to be given explicitly- but they ** are likely the return of nrrdDomainAxesGet ** ** The computed origin is put into the given vector ( origin ). The return ** value takes on values from the nrrdOriginStatus* enum: ** ** nrrdOriginStatusUnknown: invalid arguments ( e.g. NULL pointer, or ** axis values out of range ) ** ** nrrdOriginStatusDirection: the chosen axes have spaceDirection set, ** which means caller should instead be using ** nrrdSpaceOriginGet ** ** nrrdOriginStatusNoMin: can't compute "origin" without axis->min ** ** nrrdOriginStatusNoMaxOrSpacing: can't compute origin without ( axis->min ** and ) either axis->max or axis->spacing ** ** nrrdOriginStatusOkay: all is well */ int 231 nrrdOriginCalculate( const Nrrd *nrrd, unsigned int *axisIdx, unsigned int axisIdxNum, int defaultCenter, double *origin ) { const NrrdAxisInfo *axis[NRRD_SPACE_DIM_MAX]; int center, okay, gotSpace, gotMin, gotMaxOrSpacing; unsigned int ai; double min, spacing; #define ERROR \ if ( origin ) { \ for ( ai=0; ai<axisIdxNum; ai++ ) { \ origin[ai] = AIR_NAN; \ } \ } if ( !( nrrd && ( nrrdCenterCell == defaultCenter || nrrdCenterNode == defaultCenter ) && origin ) ) { ERROR; return nrrdOriginStatusUnknown; } okay = AIR_TRUE; for ( ai=0; ai<axisIdxNum; ai++ ) { okay &= axisIdx[ai] < nrrd->dim; } if ( !okay ) { ERROR; return nrrdOriginStatusUnknown; } /* learn axisInfo pointers */ for ( ai=0; ai<axisIdxNum; ai++ ) { axis[ai] = nrrd->axis + axisIdx[ai]; } gotSpace = AIR_FALSE; for ( ai=0; ai<axisIdxNum; ai++ ) { gotSpace |= AIR_EXISTS( axis[ai]->spaceDirection[0] ); } if ( nrrd->spaceDim > 0 && gotSpace ) { ERROR; return nrrdOriginStatusDirection; } gotMin = AIR_TRUE; for ( ai=0; ai<axisIdxNum; ai++ ) { gotMin &= AIR_EXISTS( axis[0]->min ); } if ( !gotMin ) { ERROR; return nrrdOriginStatusNoMin; } gotMaxOrSpacing = AIR_TRUE; for ( ai=0; ai<axisIdxNum; ai++ ) { gotMaxOrSpacing &= ( AIR_EXISTS( axis[ai]->max ) || AIR_EXISTS( axis[ai]->spacing ) ); } if ( !gotMaxOrSpacing ) { ERROR; return nrrdOriginStatusNoMaxOrSpacing; } for ( ai=0; ai<axisIdxNum; ai++ ) { size_t size; double denom; size = axis[ai]->size; min = axis[ai]->min; center = ( nrrdCenterUnknown != axis[ai]->center ? axis[ai]->center : defaultCenter ); denom = AIR_CAST( double, nrrdCenterCell == center ? size : size-1 ); spacing = ( AIR_EXISTS( axis[ai]->spacing ) ? axis[ai]->spacing : ( axis[ai]->max - min )/denom ); origin[ai] = min + ( nrrdCenterCell == center ? spacing/2 : 0 ); 309 } return nrrdOriginStatusOkay; } void nrrdSpaceVecCopy( double dst[NRRD_SPACE_DIM_MAX], const double src[NRRD_SPACE_DIM_MAX] ) { unsigned int ii; for ( ii=0; ii<NRRD_SPACE_DIM_MAX; ii++ ) { dst[ii] = src[ii]; } } /* ** NOTE: since this was created until Wed Sep 21 13:34:17 EDT 2005, ** nrrdSpaceVecScaleAdd2 and nrrdSpaceVecScale would treat a ** non-existent vector coefficient as 0.0. The reason for this had ** to do with how the function is used. For example, in nrrdCrop ** ** _nrrdSpaceVecCopy( nout->spaceOrigin, nin->spaceOrigin ); ** for ( ai=0; ai<nin->dim; ai++ ) { ** _nrrdSpaceVecScaleAdd2( nout->spaceOrigin, ** 1.0, nout->spaceOrigin, ** min[ai], nin->axis[ai].spaceDirection ); ** } ** ** but the problem with this is that non-spatial axes end up clobbering ** the existance of otherwise existing spaceOrigin and spaceDirections. ** It was decided, however, that this logic should be outside the 339 ** arithmetic functions below, not inside. NOTE: the old functionality ** is stuck in ITK 2.2, via NrrdIO. */ void nrrdSpaceVecScaleAdd2( double sum[NRRD_SPACE_DIM_MAX], double sclA, const double vecA[NRRD_SPACE_DIM_MAX], double sclB, const double vecB[NRRD_SPACE_DIM_MAX] ) { unsigned int ii; for ( ii=0; ii<NRRD_SPACE_DIM_MAX; ii++ ) { 350 sum[ii] = sclA*vecA[ii] + sclB*vecB[ii]; } } void nrrdSpaceVecScale( double out[NRRD_SPACE_DIM_MAX], double scl, const double vec[NRRD_SPACE_DIM_MAX] ) { unsigned int ii; for ( ii=0; ii<NRRD_SPACE_DIM_MAX; ii++ ) { 360 out[ii] = scl*vec[ii]; } } double nrrdSpaceVecNorm( unsigned int sdim, const double vec[NRRD_SPACE_DIM_MAX] ) { unsigned int di; double nn; nn = 0; for ( di=0; di<sdim; di++ ) { nn += vec[di]*vec[di]; 372 } return sqrt( nn ); } void nrrdSpaceVecSetNaN( double vec[NRRD_SPACE_DIM_MAX] ) { unsigned int di; for ( di=0; di<NRRD_SPACE_DIM_MAX; di++ ) { vec[di] = AIR_NAN; } return; 384 } /* ---- BEGIN non-NrrdIO */ void nrrdSpaceVecSetZero( double vec[NRRD_SPACE_DIM_MAX] ) { int di; for ( di=0; di<NRRD_SPACE_DIM_MAX; di++ ) { vec[di] = 0; } return; } /* ---- END non-NrrdIO */ /* ** _nrrdContentGet 401 ** ** ALLOCATES a string for the content of a given nrrd ** panics if allocation failed */ char * _nrrdContentGet( const Nrrd *nin ) { static const char me[]="_nrrdContentGet"; char *ret; ret = ( ( nin && nin->content ) ? airStrdup( nin->content ) : airStrdup( nrrdStateUnknownContent ) ); if ( !ret ) { fprintf( stderr, "%s: PANIC: content strdup failed!\n", me ); return NULL; 416 } return ret; } int _nrrdContentSet_nva( Nrrd *nout, const char *func, char *content, const char *format, va_list arg ) { static const char me[]="_nrrdContentSet_nva"; char *buff; if ( nrrdStateDisableContent ) { /* we kill content always */ nout->content = ( char * )airFree( nout->content ); return 0; } buff = ( char * )malloc( 128*AIR_STRLEN_HUGE ); if ( !buff ) { biffAddf( NRRD, "%s: couln't alloc buffer!", me ); return 1; } nout->content = ( char * )airFree( nout->content ); /* we are currently praying that this won't overflow the "buff" array */ /* HEY: replace with vsnprintf or whatever when its available */ vsprintf( buff, format, arg ); nout->content = ( char * )calloc( strlen( "( , )" ) + airStrlen( func ) + 1 /* '( ' */ + airStrlen( content ) + 1 /* ', ' */ + airStrlen( buff ) + 1 /* ' )' */ + 1, sizeof( char ) ); /* '\0' */ if ( !nout->content ) { biffAddf( NRRD, "%s: couln't alloc output content!", me ); airFree( buff ); return 1; } sprintf( nout->content, "%s( %s%s%s )", func, content, airStrlen( buff ) ? ", " : "", buff ); 456 airFree( buff ); /* no NULL assignment, else compile warnings */ return 0; } int _nrrdContentSet_va( Nrrd *nout, const char *func, char *content, const char *format, ... ) { static const char me[]="_nrrdContentSet_va"; va_list ap; va_start( ap, format ); if ( _nrrdContentSet_nva( nout, func, content, format, ap ) ) { biffAddf( NRRD, "%s:", me ); free( content ); return 1; } va_end( ap ); /* free( content ); */ return 0; } /* ******** nrrdContentSet ** ** Kind of like sprintf, but for the content string of the nrrd. ** ** Whether or not we write a new content for an old nrrd ( "nin" ) with ** NULL content is decided here, according to ** nrrdStateAlwaysSetContent. 485 ** ** Does the string allocation and some attempts at error detection. ** Does allow nout==nin, which requires some care. */ int nrrdContentSet_va( Nrrd *nout, const char *func, const Nrrd *nin, const char *format, ... ) { static const char me[]="nrrdContentSet_va"; va_list ap; char *content; if ( !( nout && func && nin && format ) ) { biffAddf( NRRD, "%s: got NULL pointer", me ); return 1; } if ( nrrdStateDisableContent ) { /* we kill content always */ nout->content = ( char * )airFree( nout->content ); return 0; } if ( !nin->content && !nrrdStateAlwaysSetContent ) { /* there's no input content, and we're not supposed to invent any content, so after freeing nout's content we're done */ nout->content = ( char * )airFree( nout->content ); return 0; } /* we copy the input nrrd content first, before blowing away the output content, in case nout == nin */ content = _nrrdContentGet( nin ); va_start( ap, format ); if ( _nrrdContentSet_nva( nout, func, content, format, ap ) ) { biffAddf( NRRD, "%s:", me ); va_end( ap ); free( content ); return 1; } va_end( ap ); free( content ); return 0; } /* 526 ******** nrrdDescribe ** ** writes verbose description of nrrd to given file */ void nrrdDescribe( FILE *file, const Nrrd *nrrd ) { unsigned int ai; char stmp[AIR_STRLEN_SMALL]; if ( file && nrrd ) { fprintf( file, "Nrrd at 0x%p:\n", AIR_CVOIDP( nrrd ) ); fprintf( file, "Data at 0x%p is %s elements of type %s.\n", nrrd->data, airSprintSize_t( stmp, nrrdElementNumber( nrrd ) ), airEnumStr( nrrdType, nrrd->type ) ); if ( nrrdTypeBlock == nrrd->type ) { fprintf( file, "The blocks have size %s\n", airSprintSize_t( stmp, nrrd->blockSize ) ); } if ( airStrlen( nrrd->content ) ) { fprintf( file, "Content = \"%s\"\n", nrrd->content ); } fprintf( file, "%d-dimensional array, with axes:\n", nrrd->dim ); for ( ai=0; ai<nrrd->dim; ai++ ) { if ( airStrlen( nrrd->axis[ai].label ) ) { fprintf( file, "%d: ( \"%s\" ) ", ai, nrrd->axis[ai].label ); } else { fprintf( file, "%d: ", ai ); } fprintf( file, "%s-centered, size=%s, ", airEnumStr( nrrdCenter, nrrd->axis[ai].center ), airSprintSize_t( stmp, nrrd->axis[ai].size ) ); airSinglePrintf( file, NULL, "spacing=%lg, \n", nrrd->axis[ai].spacing ); airSinglePrintf( file, NULL, "thickness=%lg, \n", nrrd->axis[ai].thickness ); airSinglePrintf( file, NULL, " axis( Min, Max ) = ( %lg, ", nrrd->axis[ai].min ); airSinglePrintf( file, NULL, "%lg )\n", nrrd->axis[ai].max ); if ( airStrlen( nrrd->axis[ai].units ) ) { fprintf( file, "units=%s, \n", nrrd->axis[ai].units ); } } /* airSinglePrintf( file, NULL, "The min, max values are %lg", nrrd->min ); airSinglePrintf( file, NULL, ", %lg\n", nrrd->max ); */ airSinglePrintf( file, NULL, "The old min, old max values are %lg", nrrd->oldMin ); airSinglePrintf( file, NULL, ", %lg\n", nrrd->oldMax ); /* fprintf( file, "hasNonExist = %d\n", nrrd->hasNonExist ); */ if ( nrrd->cmtArr->len ) { fprintf( file, "Comments:\n" ); for ( ai=0; ai<nrrd->cmtArr->len; ai++ ) { fprintf( file, "%s\n", nrrd->cmt[ai] ); } } 582 fprintf( file, "\n" ); } } int nrrdSpaceVecExists( unsigned int sdim, const double vec[NRRD_SPACE_DIM_MAX] ) { int exists; unsigned int ii; exists = AIR_EXISTS( vec[0] ); for ( ii=1; ii<sdim; ii++ ) { exists &= AIR_EXISTS( vec[ii] ); } return exists; } /* ** asserts all the properties associated with orientation information 600 ** ** The most important part of this is asserting the per-axis mutual ** exclusion of min/max/spacing/units versus using spaceDirection. */ static int _nrrdFieldCheckSpaceInfo( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheckSpaceInfo"; unsigned int dd, ii; int exists; if ( !( !nrrd->space || !airEnumValCheck( nrrdSpace, nrrd->space ) ) ) { biffMaybeAddf( useBiff, NRRD, "%s: space %d invalid", me, nrrd->space ); return 1; } if ( !( nrrd->spaceDim <= NRRD_SPACE_DIM_MAX ) ) { biffMaybeAddf( useBiff, NRRD, "%s: space dimension %d is outside " "valid range [0, NRRD_SPACE_DIM_MAX] = [0, %d]", me, nrrd->dim, NRRD_SPACE_DIM_MAX ); return 1; } if ( nrrd->spaceDim ) { if ( nrrd->space ) { if ( nrrdSpaceDimension( nrrd->space ) != nrrd->spaceDim ) { biffMaybeAddf( useBiff, NRRD, "%s: space %s has dimension %d but spaceDim is %d", me, airEnumStr( nrrdSpace, nrrd->space ), nrrdSpaceDimension( nrrd->space ), nrrd->spaceDim ); return 1; } } /* check that all coeffs of spaceOrigin have consistent existance */ exists = AIR_EXISTS( nrrd->spaceOrigin[0] ); for ( ii=0; ii<nrrd->spaceDim; ii++ ) { if ( exists ^ AIR_EXISTS( nrrd->spaceOrigin[ii] ) ) { biffMaybeAddf( useBiff, NRRD, "%s: existance of space origin coefficients must " "be consistent ( val[0] not like val[%d] )", me, ii ); return 1; } } /* check that all coeffs of measurementFrame have consistent existance */ exists = AIR_EXISTS( nrrd->measurementFrame[0][0] ); for ( dd=0; dd<nrrd->spaceDim; dd++ ) { for ( ii=0; ii<nrrd->spaceDim; ii++ ) { if ( exists ^ AIR_EXISTS( nrrd->measurementFrame[dd][ii] ) ) { biffMaybeAddf( useBiff, NRRD, "%s: existance of measurement frame coefficients " "must be consistent: [col][row] [%d][%d] not " "like [0][0] )", me, dd, ii ); return 1; } } } /* check on space directions */ for ( dd=0; dd<nrrd->dim; dd++ ) { exists = AIR_EXISTS( nrrd->axis[dd].spaceDirection[0] ); for ( ii=1; ii<nrrd->spaceDim; ii++ ) { if ( exists ^ AIR_EXISTS( nrrd->axis[dd].spaceDirection[ii] ) ) { biffMaybeAddf( useBiff, NRRD, "%s: existance of space direction %d coefficients " "must be consistent ( val[0] not like val[%d] )", me, dd, ii ); return 1; } } if ( exists ) { if ( AIR_EXISTS( nrrd->axis[dd].min ) || AIR_EXISTS( nrrd->axis[dd].max ) || AIR_EXISTS( nrrd->axis[dd].spacing ) || !!airStrlen( nrrd->axis[dd].units ) ) { biffMaybeAddf( useBiff, NRRD, "%s: axis[%d] has a direction vector, and so can't " "have min, max, spacing, or units set", me, dd ); return 1; } } } } else { /* else there's not supposed to be anything in "space" */ if ( nrrd->space ) { biffMaybeAddf( useBiff, NRRD, "%s: space %s can't be set with spaceDim %d", me, airEnumStr( nrrdSpace, nrrd->space ), nrrd->spaceDim ); return 1; } /* -------- */ exists = AIR_FALSE; for ( dd=0; dd<NRRD_SPACE_DIM_MAX; dd++ ) { exists |= !!airStrlen( nrrd->spaceUnits[dd] ); } if ( exists ) { biffMaybeAddf( useBiff, NRRD, "%s: spaceDim is 0, but space units is set", me ); return 1; } /* -------- */ exists = AIR_FALSE; for ( dd=0; dd<NRRD_SPACE_DIM_MAX; dd++ ) { exists |= AIR_EXISTS( nrrd->spaceOrigin[dd] ); } if ( exists ) { biffMaybeAddf( useBiff, NRRD, "%s: spaceDim is 0, but space origin is set", me ); return 1; } /* -------- */ exists = AIR_FALSE; for ( dd=0; dd<NRRD_SPACE_DIM_MAX; dd++ ) { for ( ii=0; ii<NRRD_DIM_MAX; ii++ ) { exists |= AIR_EXISTS( nrrd->axis[ii].spaceDirection[dd] ); } } if ( exists ) { biffMaybeAddf( useBiff, NRRD, "%s: spaceDim is 0, but space directions are set", me ); return 1; } } return 0; } /* --------------------- per-field checks ---------------- ** ** Strictly speacking, these checks only apply to the nrrd itself, not ** to a potentially incomplete nrrd in the process of being read, so ** the NrrdIoState stuff is not an issue. This limits the utility of ** these to the field parsers for handling the more complex state ** involved in parsing some of the NRRD fields ( like units ). 729 ** ** return 0 if it is valid, and 1 if there is an error */ static int _nrrdFieldCheck_noop( const Nrrd *nrrd, int useBiff ) { AIR_UNUSED( nrrd ); 737 AIR_UNUSED( useBiff ); return 0; } static int _nrrdFieldCheck_type( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_type"; if ( airEnumValCheck( nrrdType, nrrd->type ) ) { biffMaybeAddf( useBiff, NRRD, "%s: type ( %d ) is not valid", me, nrrd->type ); return 1; 749 } return 0; } static int _nrrdFieldCheck_block_size( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_block_size"; char stmp[AIR_STRLEN_SMALL]; if ( nrrdTypeBlock == nrrd->type && ( !( 0 < nrrd->blockSize ) ) ) { biffMaybeAddf( useBiff, NRRD, "%s: type is %s but nrrd->blockSize ( %s ) invalid", me, airEnumStr( nrrdType, nrrdTypeBlock ), airSprintSize_t( stmp, nrrd->blockSize ) ); return 1; } if ( nrrdTypeBlock != nrrd->type && ( 0 < nrrd->blockSize ) ) { biffMaybeAddf( useBiff, NRRD, "%s: type is %s ( not block ) but blockSize is %s", me, airEnumStr( nrrdType, nrrd->type ), airSprintSize_t( stmp, nrrd->blockSize ) ); return 1; 770 } return 0; } static int _nrrdFieldCheck_dimension( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_dimension"; if ( !AIR_IN_CL( 1, nrrd->dim, NRRD_DIM_MAX ) ) { biffMaybeAddf( useBiff, NRRD, "%s: dimension %u is outside valid range [1, %d]", me, nrrd->dim, NRRD_DIM_MAX ); return 1; 783 } return 0; } static int _nrrdFieldCheck_space( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_space"; if ( _nrrdFieldCheckSpaceInfo( nrrd, useBiff ) ) { biffMaybeAddf( useBiff, NRRD, "%s: trouble", me ); return 1; 794 } return 0; } static int _nrrdFieldCheck_space_dimension( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_space_dimension"; if ( _nrrdFieldCheckSpaceInfo( nrrd, useBiff ) ) { biffMaybeAddf( useBiff, NRRD, "%s: trouble", me ); return 1; 805 } return 0; } static int _nrrdFieldCheck_sizes( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_sizes"; size_t size[NRRD_DIM_MAX]; nrrdAxisInfoGet_nva( nrrd, nrrdAxisInfoSize, size ); if ( _nrrdSizeCheck( size, nrrd->dim, useBiff ) ) { biffMaybeAddf( useBiff, NRRD, "%s: trouble with array sizes", me ); return 1; 818 } return 0; } static int _nrrdFieldCheck_spacings( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_spacings"; double val[NRRD_DIM_MAX]; unsigned int ai; nrrdAxisInfoGet_nva( nrrd, nrrdAxisInfoSpacing, val ); for ( ai=0; ai<nrrd->dim; ai++ ) { if ( !( !airIsInf_d( val[ai] ) && ( airIsNaN( val[ai] ) || ( 0 != val[ai] ) ) ) ) { biffMaybeAddf( useBiff, NRRD, "%s: axis %d spacing ( %g ) invalid", me, ai, val[ai] ); return 1; } } if ( _nrrdFieldCheckSpaceInfo( nrrd, useBiff ) ) { biffMaybeAddf( useBiff, NRRD, "%s: trouble", me ); return 1; 839 } return 0; } static int _nrrdFieldCheck_thicknesses( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_thicknesses"; double val[NRRD_DIM_MAX]; unsigned int ai; nrrdAxisInfoGet_nva( nrrd, nrrdAxisInfoThickness, val ); for ( ai=0; ai<nrrd->dim; ai++ ) { /* note that unlike spacing, we allow zero thickness, but it makes no sense to be negative */ if ( !( !airIsInf_d( val[ai] ) && ( airIsNaN( val[ai] ) || ( 0 <= val[ai] ) ) ) ) { biffMaybeAddf( useBiff, NRRD, "%s: axis %d thickness ( %g ) invalid", me, ai, val[ai] ); return 1; } 858 } return 0; } static int _nrrdFieldCheck_axis_mins( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_axis_mins"; double val[NRRD_DIM_MAX]; unsigned int ai; int ret; nrrdAxisInfoGet_nva( nrrd, nrrdAxisInfoMin, val ); for ( ai=0; ai<nrrd->dim; ai++ ) { if ( ( ret=airIsInf_d( val[ai] ) ) ) { biffMaybeAddf( useBiff, NRRD, "%s: axis %d min %sinf invalid", me, ai, 1==ret ? "+" : "-" ); return 1; } } if ( _nrrdFieldCheckSpaceInfo( nrrd, useBiff ) ) { biffMaybeAddf( useBiff, NRRD, "%s: trouble", me ); return 1; } 881 /* HEY: contemplate checking min != max, but what about stub axes ... */ return 0; } static int _nrrdFieldCheck_axis_maxs( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_axis_maxs"; double val[NRRD_DIM_MAX]; unsigned int ai; int ret; nrrdAxisInfoGet_nva( nrrd, nrrdAxisInfoMax, val ); for ( ai=0; ai<nrrd->dim; ai++ ) { if ( ( ret=airIsInf_d( val[ai] ) ) ) { biffMaybeAddf( useBiff, NRRD, "%s: axis %d max %sinf invalid", me, ai, 1==ret ? "+" : "-" ); return 1; } } if ( _nrrdFieldCheckSpaceInfo( nrrd, useBiff ) ) { biffMaybeAddf( useBiff, NRRD, "%s: trouble", me ); return 1; } 904 /* HEY: contemplate checking min != max, but what about stub axes ... */ return 0; } static int _nrrdFieldCheck_space_directions( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_space_directions"; if ( _nrrdFieldCheckSpaceInfo( nrrd, useBiff ) ) { biffMaybeAddf( useBiff, NRRD, "%s: space info problem", me ); return 1; 915 } return 0; } static int _nrrdFieldCheck_centers( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_centers"; unsigned int ai; int val[NRRD_DIM_MAX]; nrrdAxisInfoGet_nva( nrrd, nrrdAxisInfoCenter, val ); for ( ai=0; ai<nrrd->dim; ai++ ) { if ( !( nrrdCenterUnknown == val[ai] || !airEnumValCheck( nrrdCenter, val[ai] ) ) ) { biffMaybeAddf( useBiff, NRRD, "%s: axis %d center %d invalid", me, ai, val[ai] ); return 1; } 933 } return 0; } static int _nrrdFieldCheck_kinds( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_kinds"; int val[NRRD_DIM_MAX]; unsigned int wantLen, ai; nrrdAxisInfoGet_nva( nrrd, nrrdAxisInfoKind, val ); for ( ai=0; ai<nrrd->dim; ai++ ) { if ( !( nrrdKindUnknown == val[ai] || !airEnumValCheck( nrrdKind, val[ai] ) ) ) { biffMaybeAddf( useBiff, NRRD, "%s: axis %d kind %d invalid", me, ai, val[ai] ); return 1; } wantLen = nrrdKindSize( val[ai] ); if ( wantLen && wantLen != nrrd->axis[ai].size ) { char stmp[AIR_STRLEN_SMALL]; biffMaybeAddf( useBiff, NRRD, "%s: axis %d kind %s requires size %u, but have %s", me, ai, airEnumStr( nrrdKind, val[ai] ), wantLen, airSprintSize_t( stmp, nrrd->axis[ai].size ) ); return 1; } 960 } return 0; } static int _nrrdFieldCheck_labels( const Nrrd *nrrd, int useBiff ) { /* char me[]="_nrrdFieldCheck_labels"; */ AIR_UNUSED( nrrd ); AIR_UNUSED( useBiff ); /* don't think there's anything to do here: the label strings are either NULL ( which is okay ) or non-NULL, but we have no restrictions on the validity of the strings */ 974 return 0; } static int _nrrdFieldCheck_units( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_units"; /* as with labels- the strings themselves don't need checking themselves */ /* but per-axis units cannot be set for axes with space directions ... */ if ( _nrrdFieldCheckSpaceInfo( nrrd, useBiff ) ) { biffMaybeAddf( useBiff, NRRD, "%s: space info problem", me ); return 1; 987 } return 0; } static int _nrrdFieldCheck_old_min( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_old_min"; int ret; if ( ( ret=airIsInf_d( nrrd->oldMin ) ) ) { biffMaybeAddf( useBiff, NRRD, "%s: old min %sinf invalid", me, 1==ret ? "+" : "-" ); return 1; } 1001 /* oldMin == oldMax is perfectly valid */ return 0; } static int _nrrdFieldCheck_old_max( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_old_max"; int ret; if ( ( ret=airIsInf_d( nrrd->oldMax ) ) ) { biffMaybeAddf( useBiff, NRRD, "%s: old max %sinf invalid", me, 1==ret ? "+" : "-" ); return 1; } 1015 /* oldMin == oldMax is perfectly valid */ return 0; } static int _nrrdFieldCheck_keyvalue( const Nrrd *nrrd, int useBiff ) { /* char me[]="_nrrdFieldCheck_keyvalue"; */ AIR_UNUSED( nrrd ); AIR_UNUSED( useBiff ); /* nrrdKeyValueAdd( ) ensures that keys aren't repeated, not sure what other kind of checking can be done */ 1028 return 0; } static int _nrrdFieldCheck_space_units( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_space_units"; /* not sure if there's anything to specifically check for the space units themselves ... */ if ( _nrrdFieldCheckSpaceInfo( nrrd, useBiff ) ) { biffMaybeAddf( useBiff, NRRD, "%s: space info problem", me ); return 1; 1041 } return 0; } static int _nrrdFieldCheck_space_origin( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_space_origin"; /* pre-Fri Feb 11 04:25:36 EST 2005, I thought that the spaceOrigin must be known to describe the space/orientation stuff, but that's too restrictive, which is why below says AIR_FALSE instead of AIR_TRUE */ if ( _nrrdFieldCheckSpaceInfo( nrrd, useBiff ) ) { biffMaybeAddf( useBiff, NRRD, "%s: space info problem", me ); return 1; 1056 } return 0; } static int _nrrdFieldCheck_measurement_frame( const Nrrd *nrrd, int useBiff ) { static const char me[]="_nrrdFieldCheck_measurement_frame"; if ( _nrrdFieldCheckSpaceInfo( nrrd, useBiff ) ) { biffMaybeAddf( useBiff, NRRD, "%s: space info problem", me ); 1066 return 1; } return 0; } int ( *_nrrdFieldCheck[NRRD_FIELD_MAX+1] )( const Nrrd *, int useBiff ) = { _nrrdFieldCheck_noop, /* nonfield */ _nrrdFieldCheck_noop, /* comment */ _nrrdFieldCheck_noop, /* content */ _nrrdFieldCheck_noop, /* number */ _nrrdFieldCheck_type, _nrrdFieldCheck_block_size, _nrrdFieldCheck_dimension, _nrrdFieldCheck_space, _nrrdFieldCheck_space_dimension, _nrrdFieldCheck_sizes, _nrrdFieldCheck_spacings, _nrrdFieldCheck_thicknesses, _nrrdFieldCheck_axis_mins, _nrrdFieldCheck_axis_maxs, _nrrdFieldCheck_space_directions, _nrrdFieldCheck_centers, _nrrdFieldCheck_kinds, _nrrdFieldCheck_labels, _nrrdFieldCheck_units, _nrrdFieldCheck_noop, /* min */ _nrrdFieldCheck_noop, /* max */ _nrrdFieldCheck_old_min, _nrrdFieldCheck_old_max, _nrrdFieldCheck_noop, /* endian */ _nrrdFieldCheck_noop, /* encoding */ _nrrdFieldCheck_noop, /* line_skip */ _nrrdFieldCheck_noop, /* byte_skip */ _nrrdFieldCheck_keyvalue, _nrrdFieldCheck_noop, /* sample units */ _nrrdFieldCheck_space_units, _nrrdFieldCheck_space_origin, 1104 _nrrdFieldCheck_measurement_frame, _nrrdFieldCheck_noop, /* data_file */ }; int _nrrdCheck( const Nrrd *nrrd, int checkData, int useBiff ) { static const char me[]="_nrrdCheck"; int fi; if ( !nrrd ) { biffMaybeAddf( useBiff, NRRD, "%s: got NULL pointer", me ); return 1; } if ( checkData ) { if ( !( nrrd->data ) ) { biffMaybeAddf( useBiff, NRRD, "%s: nrrd %p has NULL data pointer", me, AIR_CVOIDP( nrrd ) ); return 1; } } for ( fi=nrrdField_unknown+1; fi<nrrdField_last; fi++ ) { /* yes, this will call _nrrdFieldCheckSpaceInfo( ) many many times */ if ( _nrrdFieldCheck[fi]( nrrd, AIR_TRUE ) ) { biffMaybeAddf( useBiff, NRRD, "%s: trouble with %s field", me, airEnumStr( nrrdField, fi ) ); return 1; } } return 0; } /* ******** nrrdCheck( ) ** ** does some consistency checks for things that can go wrong in a nrrd ** returns non-zero if there is a problem, zero if no problem. ** 1141 ** You might think that this should be merged with _nrrdHeaderCheck( ), ** but that is really only for testing sufficiency of information ** required to do the data reading. */ int /*Teem: biff if ( ret ) */ nrrdCheck( const Nrrd *nrrd ) { static const char me[]="nrrdCheck"; if ( _nrrdCheck( nrrd, AIR_TRUE, AIR_TRUE ) ) { biffAddf( NRRD, "%s: trouble", me ); return 1; } return 0; } /* ******** nrrdSameSize( ) ** ** returns 1 iff given two nrrds have same dimension and axes sizes. ** This does NOT look at the type of the elements. ** 1162 ** The intended user of this is someone who really wants the nrrds to be ** the same size, so that if they aren't, some descriptive ( error ) message ** can be generated according to useBiff */ int /*Teem: biff?2 if ( !ret ) */ nrrdSameSize( const Nrrd *n1, const Nrrd *n2, int useBiff ) { static const char me[]="nrrdSameSize"; unsigned int ai; char stmp[2][AIR_STRLEN_SMALL]; if ( !( n1 && n2 ) ) { biffMaybeAddf( useBiff, NRRD, "%s: got NULL pointer", me ); return 0; } if ( n1->dim != n2->dim ) { biffMaybeAddf( useBiff, NRRD, "%s: n1->dim ( %u ) != n2->dim ( %u )", me, n1->dim, n2->dim ); return 0; } for ( ai=0; ai<n1->dim; ai++ ) { if ( n1->axis[ai].size != n2->axis[ai].size ) { biffMaybeAddf( useBiff, NRRD, "%s: n1->axis[%d].size ( %s ) " "!= n2->axis[%d].size ( %s )", me, ai, airSprintSize_t( stmp[0], n1->axis[ai].size ), ai, airSprintSize_t( stmp[1], n2->axis[ai].size ) ); return 0; } } return 1; } /* ******** nrrdElementSize( ) ** ** So just how many bytes long is one element in this nrrd? This is ** needed ( over the simple nrrdTypeSize[] array ) because some nrrds ** may be of "block" type, and because it does bounds checking on ** nrrd->type. Returns 0 if given a bogus nrrd->type, or if the block ** size isn't greater than zero ( in which case it sets nrrd->blockSize ** to 0, just out of spite ). This function never returns a negative ** value; using ( !nrrdElementSize( nrrd ) ) is a sufficient check for ** invalidity. 1204 ** ** Besides learning how many bytes long one element is, this function ** is useful as a way of detecting an invalid blocksize on a block nrrd. */ size_t nrrdElementSize ( const Nrrd *nrrd ) { if ( !( nrrd && !airEnumValCheck( nrrdType, nrrd->type ) ) ) { return 0; } if ( nrrdTypeBlock != nrrd->type ) { return nrrdTypeSize[nrrd->type]; } /* else its block type */ if ( nrrd->blockSize > 0 ) { return nrrd->blockSize; } /* else we got an invalid block size */ /* nrrd->blockSize = 0; */ return 0; } /* ******** nrrdElementNumber( ) ** ** takes the place of old "nrrd->num": the number of elements in the ** nrrd, which is just the product of the axis sizes. A return of 0 1231 ** means there's a problem. Negative numbers are never returned. ** ** does NOT use biff */ size_t nrrdElementNumber ( const Nrrd *nrrd ) { size_t num, size[NRRD_DIM_MAX]; unsigned int ai; if ( !nrrd ) { return 0; } /* else */ nrrdAxisInfoGet_nva( nrrd, nrrdAxisInfoSize, size ); if ( _nrrdSizeCheck( size, nrrd->dim, AIR_FALSE ) ) { /* the nrrd's size information is invalid, can't proceed */ return 0; } num = 1; for ( ai=0; ai<nrrd->dim; ai++ ) { /* negative numbers and overflow were caught by _nrrdSizeCheck( ) */ num *= size[ai]; } return num; } 1256 /* ** obviously, this requires that the per-axis size fields have been set */ void _nrrdSplitSizes( size_t *pieceSize, size_t *pieceNum, Nrrd *nrrd, unsigned int split ) { unsigned int ai; size_t size[NRRD_DIM_MAX]; nrrdAxisInfoGet_nva( nrrd, nrrdAxisInfoSize, size ); *pieceSize = 1; for ( ai=0; ai<split; ai++ ) { *pieceSize *= size[ai]; } *pieceNum = 1; for ( ai=split; ai<nrrd->dim; ai++ ) { *pieceNum *= size[ai]; } return; } /* ******** nrrdHasNonExistSet( ) ** ** This function will always ( assuming type is valid ) set the value of ** nrrd->hasNonExist to either nrrdNonExistTrue or nrrdNonExistFalse, ** and it will return that value. For lack of a more sophisticated ** policy, blocks are currently always considered to be existent ** values ( because nrrdTypeIsIntegral[nrrdTypeBlock] is currently true ). ** This function will ALWAYS determine the correct answer and set the ** value of nrrd->hasNonExist: it ignores the value of ** nrrd->hasNonExist on the input nrrd. Exception: if nrrd is null or ** type is bogus, no action is taken and nrrdNonExistUnknown is ** returned. ** ** Because this will return either nrrdNonExistTrue or nrrdNonExistFalse, ** and because the C boolean value of these are true and false ( respectively ), ** it is possible ( and encouraged ) to use the return of this function ** as the expression of a conditional: ** ** if ( nrrdHasNonExistSet( nrrd ) ) { ** ... handle existance of non-existent values ... ** } */ /* int nrrdHasNonExistSet( Nrrd *nrrd ) { size_t I, N; float val; if ( !( nrrd && !airEnumValCheck( nrrdType, nrrd->type ) ) ) return nrrdNonExistUnknown; if ( nrrdTypeIsIntegral[nrrd->type] ) { nrrd->hasNonExist = nrrdNonExistFalse; } else { nrrd->hasNonExist = nrrdNonExistFalse; N = nrrdElementNumber( nrrd ); for ( I=0; I<N; I++ ) { val = nrrdFLookup[nrrd->type]( nrrd->data, I ); if ( !AIR_EXISTS( val ) ) { nrrd->hasNonExist = nrrdNonExistTrue; break; } } } 1323 return nrrd->hasNonExist; } */ static int _nrrdCheckEnums( void ) { static const char me[]="_nrrdCheckEnums"; char which[AIR_STRLEN_SMALL]; if ( nrrdFormatTypeLast-1 != NRRD_FORMAT_TYPE_MAX ) { strcpy( which, "nrrdFormat" ); goto err; } if ( nrrdTypeLast-1 != NRRD_TYPE_MAX ) { strcpy( which, "nrrdType" ); goto err; } if ( nrrdEncodingTypeLast-1 != NRRD_ENCODING_TYPE_MAX ) { strcpy( which, "nrrdEncodingType" ); goto err; } if ( nrrdCenterLast-1 != NRRD_CENTER_MAX ) { strcpy( which, "nrrdCenter" ); goto err; } if ( nrrdAxisInfoLast-1 != NRRD_AXIS_INFO_MAX ) { strcpy( which, "nrrdAxisInfo" ); goto err; } /* can't really check on endian enum */ if ( nrrdField_last-1 != NRRD_FIELD_MAX ) { strcpy( which, "nrrdField" ); goto err; } if ( nrrdHasNonExistLast-1 != NRRD_HAS_NON_EXIST_MAX ) { strcpy( which, "nrrdHasNonExist" ); goto err; } /* ---- BEGIN non-NrrdIO */ if ( nrrdBoundaryLast-1 != NRRD_BOUNDARY_MAX ) { strcpy( which, "nrrdBoundary" ); goto err; } if ( nrrdMeasureLast-1 != NRRD_MEASURE_MAX ) { strcpy( which, "nrrdMeasure" ); goto err; } if ( nrrdUnaryOpLast-1 != NRRD_UNARY_OP_MAX ) { strcpy( which, "nrrdUnaryOp" ); goto err; } if ( nrrdBinaryOpLast-1 != NRRD_BINARY_OP_MAX ) { strcpy( which, "nrrdBinaryOp" ); goto err; } if ( nrrdTernaryOpLast-1 != NRRD_TERNARY_OP_MAX ) { strcpy( which, "nrrdTernaryOp" ); goto err; } /* ---- END non-NrrdIO */ /* no errors so far */ return 0; err: biffAddf( NRRD, "%s: Last vs. MAX incompatibility for %s enum", me, which ); return 1; } /* ****** nrrdSanity ** ** makes sure that all the basic assumptions of nrrd hold for 1384 ** the architecture/etc which we're currently running on. ** ** returns 1 if all is okay, 0 if there is a problem */ int /*Teem: biff if ( !ret ) */ nrrdSanity( void ) { static const char me[]="nrrdSanity"; int aret, type; size_t maxsize; airLLong tmpLLI; airULLong tmpULLI; static int _nrrdSanity = 0; if ( _nrrdSanity ) { /* we've been through this once before and things looked okay ... */ /* Is this thread-safe? I think so. If we assume that any two threads are going to compute the same value, isn't it the case that, at worse, both of them will go through all the tests and then set _nrrdSanity to the same thing? */ return 1; } aret = airSanity( ); if ( aret != airInsane_not ) { biffAddf( NRRD, "%s: airSanity( ) failed: %s", me, airInsaneErr( aret ) ); return 0; } /* ---- BEGIN non-NrrdIO */ /* Odd: this sanity checker isn't part of airSanity, nor can it be without adding to airInsaneErr's list of what can go wrong, but someone should be calling it, since we have no other correctness test of the Mersenne-Twister code within Teem ( not counting the CTests in teem/Testing ) */ if ( !airRandMTSanity( ) ) { biffAddf( NRRD, "%s: airRandMTSanity failed", me ); return 0; } /* ---- END non-NrrdIO */ if ( airEnumValCheck( nrrdEncodingType, nrrdDefaultWriteEncodingType ) ) { biffAddf( NRRD, "%s: nrrdDefaultWriteEncodingType ( %d ) not in valid " "range [%d, %d]", me, nrrdDefaultWriteEncodingType, nrrdEncodingTypeUnknown+1, nrrdEncodingTypeLast-1 ); return 0; } if ( airEnumValCheck( nrrdCenter, nrrdDefaultCenter ) ) { biffAddf( NRRD, "%s: nrrdDefaultCenter ( %d ) not in valid range [%d, %d]", me, nrrdDefaultCenter, nrrdCenterUnknown+1, nrrdCenterLast-1 ); return 0; } /* ---- BEGIN non-NrrdIO */ if ( !( nrrdTypeDefault == nrrdDefaultResampleType || !airEnumValCheck( nrrdType, nrrdDefaultResampleType ) ) ) { biffAddf( NRRD, "%s: nrrdDefaultResampleType ( %d ) not in valid range [%d, %d]", me, nrrdDefaultResampleType, nrrdTypeUnknown, nrrdTypeLast-1 ); return 0; } if ( airEnumValCheck( nrrdBoundary, nrrdDefaultResampleBoundary ) ) { biffAddf( NRRD, "%s: nrrdDefaultResampleBoundary ( %d ) " "not in valid range [%d, %d]", me, nrrdDefaultResampleBoundary, nrrdBoundaryUnknown+1, nrrdBoundaryLast-1 ); return 0; } if ( airEnumValCheck( nrrdType, nrrdStateMeasureType ) ) { biffAddf( NRRD, "%s: nrrdStateMeasureType ( %d ) not in valid range [%d, %d]", me, nrrdStateMeasureType, nrrdTypeUnknown+1, nrrdTypeLast-1 ); return 0; } if ( airEnumValCheck( nrrdType, nrrdStateMeasureHistoType ) ) { biffAddf( NRRD, "%s: nrrdStateMeasureHistoType ( %d ) not in " "valid range [%d, %d]", me, nrrdStateMeasureType, nrrdTypeUnknown+1, nrrdTypeLast-1 ); return 0; } /* ---- END non-NrrdIO */ if ( !( nrrdTypeSize[nrrdTypeChar] == sizeof( char ) && nrrdTypeSize[nrrdTypeUChar] == sizeof( unsigned char ) && nrrdTypeSize[nrrdTypeShort] == sizeof( short ) && nrrdTypeSize[nrrdTypeUShort] == sizeof( unsigned short ) && nrrdTypeSize[nrrdTypeInt] == sizeof( int ) && nrrdTypeSize[nrrdTypeUInt] == sizeof( unsigned int ) && nrrdTypeSize[nrrdTypeLLong] == sizeof( airLLong ) && nrrdTypeSize[nrrdTypeULLong] == sizeof( airULLong ) && nrrdTypeSize[nrrdTypeFloat] == sizeof( float ) && nrrdTypeSize[nrrdTypeDouble] == sizeof( double ) ) ) { biffAddf( NRRD, "%s: sizeof( ) for nrrd types has problem: " "expected ( %u, %u, %u, %u, %u, %u, %u, %u, %u, %u ) " "but got ( %u, %u, %u, %u, %u, %u, %u, %u, %u, %u )", me, AIR_CAST( unsigned int, nrrdTypeSize[nrrdTypeChar] ), AIR_CAST( unsigned int, nrrdTypeSize[nrrdTypeUChar] ), AIR_CAST( unsigned int, nrrdTypeSize[nrrdTypeShort] ), AIR_CAST( unsigned int, nrrdTypeSize[nrrdTypeUShort] ), AIR_CAST( unsigned int, nrrdTypeSize[nrrdTypeInt] ), AIR_CAST( unsigned int, nrrdTypeSize[nrrdTypeUInt] ), AIR_CAST( unsigned int, nrrdTypeSize[nrrdTypeLLong] ), AIR_CAST( unsigned int, nrrdTypeSize[nrrdTypeULLong] ), AIR_CAST( unsigned int, nrrdTypeSize[nrrdTypeFloat] ), AIR_CAST( unsigned int, nrrdTypeSize[nrrdTypeDouble] ), AIR_CAST( unsigned int, sizeof( char ) ), AIR_CAST( unsigned int, sizeof( unsigned char ) ), AIR_CAST( unsigned int, sizeof( short ) ), AIR_CAST( unsigned int, sizeof( unsigned short ) ), AIR_CAST( unsigned int, sizeof( int ) ), AIR_CAST( unsigned int, sizeof( unsigned int ) ), AIR_CAST( unsigned int, sizeof( airLLong ) ), AIR_CAST( unsigned int, sizeof( airULLong ) ), AIR_CAST( unsigned int, sizeof( float ) ), AIR_CAST( unsigned int, sizeof( double ) ) ); return 0; } /* check on NRRD_TYPE_SIZE_MAX */ maxsize = 0; for ( type=nrrdTypeUnknown+1; type<=nrrdTypeLast-2; type++ ) { maxsize = AIR_MAX( maxsize, nrrdTypeSize[type] ); } if ( maxsize != NRRD_TYPE_SIZE_MAX ) { biffAddf( NRRD, "%s: actual max type size is %u != %u == NRRD_TYPE_SIZE_MAX", me, AIR_CAST( unsigned int, maxsize ), NRRD_TYPE_SIZE_MAX ); return 0; } /* check on NRRD_TYPE_BIGGEST */ if ( maxsize != sizeof( NRRD_TYPE_BIGGEST ) ) { biffAddf( NRRD, "%s: actual max type size is %u != " "%u == sizeof( NRRD_TYPE_BIGGEST )", me, AIR_CAST( unsigned int, maxsize ), AIR_CAST( unsigned int, sizeof( NRRD_TYPE_BIGGEST ) ) ); return 0; } /* nrrd-defined min/max values for 64-bit integral types */ /* NOTE: because signed integral overflow is undefined in C, the tests for signed long long no longer use overflow ( and an assumption of two's complement representation ) to assess the correctness of NRRD_LLONG_MAX and NRRD_LLONG_MIN. We merely test that these values can be stored, which we do via indirect ( perhaps needlessly so ) means. ( h/t Sean McBride for pointing this out ) */ tmpLLI = _nrrdLLongMaxHelp( _nrrdLLongMaxHelp( _NRRD_LLONG_MAX_HELP ) ); if ( !( tmpLLI > 0 && NRRD_LLONG_MAX == tmpLLI ) ) { biffAddf( NRRD, "%s: long long int can't hold NRRD_LLONG_MAX ( " AIR_LLONG_FMT " )", me, NRRD_LLONG_MAX ); return 0; } tmpLLI = _nrrdLLongMinHelp( _nrrdLLongMinHelp( _NRRD_LLONG_MIN_HELP ) ); if ( !( tmpLLI < 0 && NRRD_LLONG_MIN == tmpLLI ) ) { biffAddf( NRRD, "%s: long long int can't hold NRRD_LLONG_MIN ( " AIR_LLONG_FMT " )", me, NRRD_LLONG_MIN ); return 0; } tmpULLI = _nrrdULLongMaxHelp( NRRD_ULLONG_MAX ); if ( tmpULLI != 0 ) { biffAddf( NRRD, "%s: unsigned long long int max ( " AIR_ULLONG_FMT " ) incorrect", me, NRRD_ULLONG_MAX ); return 0; } if ( _nrrdCheckEnums( ) ) { biffAddf( NRRD, "%s: problem with enum definition", me ); return 0; } if ( !( NRRD_DIM_MAX >= 3 ) ) { biffAddf( NRRD, "%s: NRRD_DIM_MAX == %u seems awfully small, doesn't it?", me, NRRD_DIM_MAX ); return 0; } if ( !nrrdTypeIsIntegral[nrrdTypeBlock] ) { biffAddf( NRRD, "%s: nrrdTypeInteger[nrrdTypeBlock] is not true, things " "could get wacky", me ); return 0; } /* HEY: any other assumptions built into Teem? */ _nrrdSanity = 1; return 1; 1580 } /* ---- BEGIN non-NrrdIO */ void nrrdSanityOrDie( const char *me ) { char *err; if ( !nrrdSanity( ) ) { fprintf( stderr, "******************************************\n" ); fprintf( stderr, "******************************************\n" ); fprintf( stderr, "\n" ); fprintf( stderr, " %s: Nrrd sanity check failed.\n", me ); fprintf( stderr, "\n" ); fprintf( stderr, " This probably means that there was an error\n" ); fprintf( stderr, " in the configuration, compilation, or basic\n" ); fprintf( stderr, " variable definitions used for building Teem.\n" ); fprintf( stderr, " Error message:\n" ); fprintf( stderr, "%s\n", err = biffGetDone( NRRD ) ); fprintf( stderr, "\n" ); fprintf( stderr, "******************************************\n" ); fprintf( stderr, "******************************************\n" ); free( err ); 1603 exit( 1 ); } } void nrrdSetZero( Nrrd *nout ) { if ( !_nrrdCheck( nout, AIR_TRUE, AIR_FALSE ) ) { memset( nout->data, 0, nrrdElementNumber( nout )*nrrdElementSize( nout ) ); 1612 } return; } void nrrdSetNaN( Nrrd *nout ) { if ( _nrrdCheck( nout, AIR_TRUE, AIR_FALSE ) ) { /* bad nrrd, oh well */ return; } /* HEY if Half is ever added we'll have to check for it here */ size_t II, NN = nrrdElementNumber( nout ); if ( nrrdTypeFloat == nout->type ) { float *ff = AIR_CAST( float *, nout->data ); for ( II=0; II<NN; II++ ) { ff[II] = AIR_NAN; } } else if ( nrrdTypeDouble == nout->type ) { double *dd = AIR_CAST( double *, nout->data ); for ( II=0; II<NN; II++ ) { dd[II] = AIR_NAN; } } return; } /* ---- END non-NrrdIO */

/Users/scm/git/github/teem/src/nrrd/subset.c

/Users/scm/git/github/teem/src/nrrd/superset.c

/Users/scm/git/github/teem/src/nrrd/test/ax.c

/Users/scm/git/github/teem/src/nrrd/test/convo.c

/Users/scm/git/github/teem/src/nrrd/test/dnorm.c

/Users/scm/git/github/teem/src/nrrd/test/genvol.c

/Users/scm/git/github/teem/src/nrrd/test/histrad.c

/Users/scm/git/github/teem/src/nrrd/test/io.c

/Users/scm/git/github/teem/src/nrrd/test/kv.c

/Users/scm/git/github/teem/src/nrrd/test/minmax.c

/Users/scm/git/github/teem/src/nrrd/test/morph.c

/Users/scm/git/github/teem/src/nrrd/test/otsu.c

/Users/scm/git/github/teem/src/nrrd/test/phrnd.c

/Users/scm/git/github/teem/src/nrrd/test/quadvol.c

/Users/scm/git/github/teem/src/nrrd/test/reuse.c

/Users/scm/git/github/teem/src/nrrd/test/strio.c

/Users/scm/git/github/teem/src/nrrd/test/texp.c

/Users/scm/git/github/teem/src/nrrd/test/tkernel.c

/Users/scm/git/github/teem/src/nrrd/test/tline.c

/Users/scm/git/github/teem/src/nrrd/test/trand.c

/Users/scm/git/github/teem/src/nrrd/test/tread.c

/Users/scm/git/github/teem/src/nrrd/test/typestest.c

/Users/scm/git/github/teem/src/nrrd/tmf/tmFilters_raw.c

1 /* Teem: Tools to process and visualize scientific data and images Copyright ( C ) 2013, 2012, 2011, 2010, 2009 University of Chicago Copyright ( C ) 2008, 2007, 2006, 2005 Gordon Kindlmann Copyright ( C ) 2004, 2003, 2002, 2001, 2000, 1999, 1998 University of Utah This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /* ### Written by Torsten Moeller ### sometime in March 1998 ### email me if you find any errors ### ### March 2003 - modified to remove coeff part */ #pragma warning( disable:4244 ) #pragma warning( disable:4305 ) #define OVER_3 0.33333333 #define OVER_6 0.16666666 #define OVER_12 0.0833333333 #define OVER_2_3 0.6666666666 #include "tmFilters_raw.h" /***************************************************************************/ /* Approximation Filters */ /***************************************************************************/ 46 float dn_cn_1ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = 0.5; break; case 1: result = 0.5; break; default: result = 0; } return result; } 62 float dn_cn_2ef( float a, float t ) { return d0_c0_2ef( a, t ); } 67 float dn_cn_3ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( 0.25*t +( 2*a-0.25 ) )*t - a ; break; case 1: result = ( -0.25*t -( 6*a-1.25 ) )*t + 3*a ; break; case 2: result = ( -0.25*t +( 6*a-0.75 ) )*t - 3*a+1; break; case 3: result = ( 0.25*t -( 2*a+0.25 ) )*t + a ; break; default: result = 0; } return result; } 85 float dn_cn_4ef( float a, float t ) { return d0_c0_4ef( a, t ); } 90 float dn_c0_1ef( float a, float t ) { return d0_c0_2ef( a, t ); } 95 float dn_c0_2ef( float a, float t ) { return d0_c0_2ef( a, t ); } 100 float dn_c0_3ef( float a, float t ) { return d0_c0_3ef( a, t ); } 105 float dn_c0_4ef( float a, float t ) { return d0_c0_4ef( a, t ); } 110 float dn_c1_1ef( float a, float t ) { return d0_c1_1ef( a, t ); } 115 float dn_c1_2ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( t )*t/4; break; case 1: result = ( -t +2 )*t/4 +0.25; break; case 2: result = ( -t )*t/4 +0.5; break; case 3: result = ( t -2 )*t/4 +0.25; break; default: result = 0; } return result; } 133 float dn_c1_3ef( float a, float t ) { return d0_c1_3ef( a, t ); } 138 float dn_c1_4ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( -( a )*t +( 1.5*a- 1./24 ) )*t + 0 )*t + 0; break; case 1: result = ( ( ( 5*a+OVER_6 )*t -( 7.5*a- 1./8 ) )*t - ( OVER_12 ) )*t +( 0.5*a-1./24 ); break; case 2: result = ( ( -( 10*a+ 0.5 )*t +( 15*a+ 5./12 ) )*t +( OVER_2_3 ) )*t -( 2*a-OVER_6 ); break; case 3: result = ( ( ( 10*a+ 0.5 )*t -( 15*a+13./12 ) )*t + 0 )*t +( 3*a+0.75 ); break; case 4: result = ( ( -( 5*a+OVER_6 )*t +( 7.5*a+ 5./8 ) )*t -( OVER_2_3 ) )*t -( 2*a-OVER_6 ); break; case 5: result = ( ( ( a )*t -( 1.5*a+ 1./24 ) )*t + ( OVER_12 ) )*t +( 0.5*a-1./24 ); break; default: result = 0; } return result; } 158 float dn_c2_1ef( float a, float t ) { return d0_c2_1ef( a, t ); } 163 float dn_c2_2ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( OVER_6*t + 0 )*t + 0 )*t + 0; break; case 1: result = ( ( -0.5*t +0.5 )*t +0.5 )*t + OVER_6; break; case 2: result = ( ( 0.5*t - 1 )*t + 0 )*t +OVER_2_3; break; case 3: result = ( ( -OVER_6*t +0.5 )*t -0.5 )*t + OVER_6; break; default: result = 0; } return result; } 181 float dn_c2_3ef( float a, float t ) { return d0_c2_3ef( a, t ); } 186 float dn_c2_4ef( float a, float t ) { return dn_c1_4ef( 1./36, t ); } 191 float dn_c3_1ef( float a, float t ) { return d0_c3_1ef( a, t ); } 196 float dn_c3_2ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( -0.10*t +0.25 )*t*t*t*t; break; case 1: result = ( ( ( 0.30*t -0.75 )*t*t +0.5 )*t +0.5 )*t +0.15; break; case 2: result = ( ( ( -0.30*t +0.75 )*t*t -1 )*t +0 )*t +0.70; break; case 3: result = ( ( ( 0.10*t -0.25 )*t*t +0.5 )*t -0.5 )*t +0.15; break; default: result = 0; } return result; } 214 float dn_c3_3ef( float a, float t ) { return d0_c3_3ef( a, t ); } 219 float dn_c3_4ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( ( 1./30*t - 1./16 )*t + 0 )*t + 0 )*t + 0 )*t + 0; break; case 1: result = ( ( ( ( -OVER_6*t +17./48 )*t +OVER_12 )*t - 1./24 )*t - OVER_12 )*t - 7./240; break; case 2: result = ( ( ( ( OVER_3*t -19./24 )*t -OVER_6 )*t +OVER_2_3 )*t +OVER_2_3 )*t + 7./60; break; case 3: result = ( ( ( ( -OVER_3*t + 7./8 )*t + 0 )*t - 1.25 )*t + 0 )*t +33./40; break; case 4: result = ( ( ( ( OVER_6*t -23./48 )*t +OVER_6 )*t +OVER_2_3 )*t -OVER_2_3 )*t + 7./60; break; case 5: result = ( ( ( ( - 1./30*t + 5./48 )*t -OVER_12 )*t - 1./24 )*t + OVER_12 )*t - 7./240; break; default: result = 0; } return result; } /***************************************************************************/ /* Interpolation Filters */ /***************************************************************************/ 243 float d0_cn_1ef( float a, float t ) { return d0_c0_2ef( a, t ); } 248 float d0_cn_2ef( float a, float t ) { return d0_c0_2ef( a, t ); } 253 float d0_cn_3ef( float a, float t ) { return d0_c0_3ef( a, t ); } 258 float d0_cn_4ef( float a, float t ) { return d0_c0_4ef( a, t ); } 263 float d0_c0_1ef( float a, float t ) { return d0_c0_2ef( a, t ); } 268 float d0_c0_2ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = t; break; case 1: result = 1-t; break; default: result = 0; } return result; } 284 float d0_c0_3ef( float a, float t ) { return dn_cn_3ef( 0, t ); } 289 float d0_c0_4ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( OVER_6*t +0 )*t -OVER_6 )*t ; break; case 1: result = ( ( -0.5*t +0.5 )*t +1 )*t ; break; case 2: result = ( ( 0.5*t -1 )*t -0.5 )*t+1; break; case 3: result = ( ( -OVER_6*t +0.5 )*t -OVER_3 )*t ; break; default: result = 0; } return result; } 308 float d0_c1_1ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( -2*t +3 )*t*t; break; case 1: result = ( 2*t -3 )*t*t +1; break; default: result = 0; } return result; } 324 float d0_c1_2ef( float a, float t ) { return d0_c1_3ef( a, t ); } 329 float d0_c1_3ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( 0.5*t -0.5 )*t +0 )*t; break; case 1: result = ( ( -1.5*t +2 )*t +0.5 )*t; break; case 2: result = ( ( 1.5*t -2.5 )*t +0 )*t +1; break; case 3: result = ( ( -0.5*t +1 )*t -0.5 )*t; break; default: result = 0; } return result; } 347 float d0_c1_4ef( float a, float t ) { return dn_c1_4ef( 1./12, t ); } 352 float d0_c2_1ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( 6*t -15 )*t +10 )*t*t*t; break; case 1: result = ( ( -6*t +15 )*t -10 )*t*t*t +1; break; default: result = 0; } return result; } 368 float d0_c2_2ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( 0.5*t -0.5 )*t + 0 )*t + 0 )*t; break; case 1: result = ( ( ( -0.5*t -0.5 )*t +1.5 )*t +0.5 )*t; break; case 2: result = ( ( ( -0.5*t +2.5 )*t - 3 )*t + 0 )*t +1; break; case 3: result = ( ( ( 0.5*t -1.5 )*t +1.5 )*t -0.5 )*t; break; default: result = 0; } return result; } 386 float d0_c2_3ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( ( -1*t +2.5 )*t -1.5 )*t +0 )*t +0 )*t ; break; case 1: result = ( ( ( ( 3*t -7.5 )*t +4.5 )*t +0.5 )*t +0.5 )*t ; break; case 2: result = ( ( ( ( -3*t +7.5 )*t -4.5 )*t -1 )*t +0 )*t +1; break; case 3: result = ( ( ( ( 1*t -2.5 )*t +1.5 )*t +0.5 )*t -0.5 )*t ; break; default: result = 0; } return result; } 404 float d0_c2_4ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( -1./12*t + 1./12 )*t + 0 )*t + 0 )*t; break; case 1: result = ( ( ( 1./4 *t + 1./12 )*t -1./4 )*t - OVER_12 )*t; break; case 2: result = ( ( ( -1./6 *t - 1 )*t +3./2 )*t +OVER_2_3 )*t; break; case 3: result = ( ( ( -1./6 *t + 5./3 )*t -5./2 )*t + 0 )*t +1; break; case 4: result = ( ( ( 1./4 *t -13./12 )*t +3./2 )*t -OVER_2_3 )*t; break; case 5: result = ( ( ( -1./12*t + 1./4 )*t -1./4 )*t + OVER_12 )*t; break; default: result = 0; } return result; } 424 float d0_c3_1ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( -20*t +70 )*t -84 )*t +35 )*t*t*t*t; break; case 1: result = ( ( ( 20*t -70 )*t +84 )*t -35 )*t*t*t*t +1; break; default: result = 0; } return result; } 440 float d0_c3_2ef( float a, float t ) { return d0_c3_3ef( a, t ); float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( ( -0.75*t +2 )*t -1.25 )*t*t +0 )*t +0 )*t ; break; case 1: result = ( ( ( ( 0.75*t -1.5 )*t +0 )*t*t +1.25 )*t +0.5 )*t ; break; case 2: result = ( ( ( ( 0.75*t -3 )*t +3.75 )*t*t -2.5 )*t +0 )*t +1; break; case 3: result = ( ( ( ( -0.75*t +2.5 )*t -2.5 )*t*t +1.25 )*t -0.5 )*t ; break; default: result = 0; } return result; } 459 float d0_c3_3ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( ( ( 3*t -10.5 )*t +12.5 )*t - 5 )*t*t +0 )*t +0 )*t ; break; case 1: result = ( ( ( ( ( -9*t +31.5 )*t -37.5 )*t +15 )*t*t +0.5 )*t +0.5 )*t ; break; case 2: result = ( ( ( ( ( 9*t -31.5 )*t +37.5 )*t -15 )*t*t -1 )*t +0 )*t +1; break; case 3: result = ( ( ( ( ( -3*t +10.5 )*t -12.5 )*t + 5 )*t*t +0.5 )*t -0.5 )*t ; break; default: result = 0; } return result; } 477 float d0_c3_4ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( ( ( 7./48*t - 3./8 )*t +11./48 )*t +0 )*t + 0 )*t + 0 )*t; break; case 1: result = ( ( ( ( ( -7./16*t + 1 )*t - 3./8 )*t +1./12 )*t - 3./16 )*t - OVER_12 )*t; break; case 2: result = ( ( ( ( ( 7./24*t - 1./4 )*t -19./24 )*t -1./6 )*t + 5./4 )*t +OVER_2_3 )*t; break; case 3: result = ( ( ( ( ( 7./24*t - 3./2 )*t + 7./3 )*t +0 )*t -17./8 )*t + 0 )*t +1; break; case 4: result = ( ( ( ( ( -7./16*t +13./8 )*t -31./16 )*t +1./6 )*t + 5./4 )*t -OVER_2_3 )*t; break; case 5: result = ( ( ( ( ( 7./48*t - 1./2 )*t +13./24 )*t -1./12 )*t - 3./16 )*t + OVER_12 )*t; break; default: result = 0; } return result; } /***************************************************************************/ /* First Derivative Filters */ /***************************************************************************/ 502 float d1_cn_1ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = 1; break; case 1: result = -1; break; default: result = 0; } return result; } 518 float d1_cn_2ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = 0.5*t +( a ); break; case 1: result = -0.5*t -( 3*a-0.5 ); break; case 2: result = -0.5*t +( 3*a ); break; case 3: result = 0.5*t -( a+0.5 ); break; default: result = 0; } return result; } 536 float d1_cn_3ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( 0.5*t +0 )*t -OVER_6; break; case 1: result = ( -1.5*t +1 )*t +1; break; case 2: result = ( 1.5*t -2 )*t -0.5; break; case 3: result = ( -0.5*t +1 )*t -OVER_3; break; default: result = 0; } return result; } 554 float d1_cn_4ef( float a, float t ) { return d1_c0_4ef( a, t ); } 559 float d1_c0_1ef( float a, float t ) { return d1_c0_2ef( a, t ); } 564 float d1_c0_2ef( float a, float t ) { return d1_cn_2ef( 0, t ); } 569 float d1_c0_3ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( a )*t -( a+OVER_12 ) )*t +0; break; case 1: result = ( -( 5*a-0.5 )*t +( 5*a+ 0.25 ) )*t -OVER_12; break; case 2: result = ( ( 10*a-1.5 )*t -( 10*a- 5./6 ) )*t +OVER_2_3; break; case 3: result = ( -( 10*a-1.5 )*t +( 10*a- 13./6 ) )*t +0; break; case 4: result = ( ( 5*a-0.5 )*t -( 5*a- 1.25 ) )*t -OVER_2_3; break; case 5: result = ( -( a )*t +( a-OVER_12 ) )*t +OVER_12; break; default: result = 0; } return result; } 589 float d1_c0_4ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( OVER_12*t +( a ) )*t -( a+ OVER_6 ) )*t +0; break; case 1: result = ( ( -0.25*t -( 5*a-0.25 ) )*t +( 5*a+ 0.75 ) )*t -OVER_12; break; case 2: result = ( ( OVER_6*t +( 10*a- 0.5 ) )*t -( 10*a+ OVER_3 ) )*t +OVER_2_3; break; case 3: result = ( ( OVER_6*t -( 10*a ) )*t +( 10*a- 5./6 ) )*t +0; break; case 4: result = ( ( -0.25*t +( 5*a+ 0.5 ) )*t -( 5*a- 0.5 ) )*t -OVER_2_3; break; case 5: result = ( ( OVER_12*t -( a+0.25 ) )*t +( a+OVER_12 ) )*t +OVER_12; break; default: result = 0; } return result; } 609 float d1_c1_1ef( float a, float t ) { return d1_c1_2ef( a, t ); } 614 float d1_c1_2ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( 0.5*t +0 )*t +0; break; case 1: result = ( -1.5*t +1 )*t +0.5; break; case 2: result = ( 1.5*t -2 )*t +0; break; case 3: result = ( -0.5*t +1 )*t -0.5; break; default: result = 0; } return result; } 632 float d1_c1_3ef( float a, float t ) { return d1_c0_3ef( -1./12, t ); } 637 float d1_c1_4ef( float a, float t ) { return d1_c0_4ef( -1./6, t ); } 642 float d1_c2_1ef( float a, float t ) { return d1_c2_2ef( a, t ); } 647 float d1_c2_2ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( -0.5*t +1 )*t*t +0 )*t +0; break; case 1: result = ( ( 1.5*t -3 )*t*t +1 )*t +0.5; break; case 2: result = ( ( -1.5*t +3 )*t*t -2 )*t +0; break; case 3: result = ( ( 0.5*t -1 )*t*t +1 )*t -0.5; break; default: result = 0; } return result; } 665 float d1_c2_3ef( float a, float t ) { return d1_c2_4ef( a, t ); } 670 float d1_c2_4ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( OVER_6*t - 0.25 )*t + 0 )*t + 0 )*t +0; break; case 1: result = ( ( ( - 5./6*t +17./12 )*t +0.25 )*t -OVER_12 )*t -OVER_12; break; case 2: result = ( ( ( 5./3*t - 19./6 )*t -0.5 )*t + 4./3 )*t +OVER_2_3; break; case 3: result = ( ( ( - 5./3*t + 3.5 )*t +0 )*t - 2.5 )*t +0; break; case 4: result = ( ( ( 5./6*t -23./12 )*t +0.5 )*t + 4./3 )*t -OVER_2_3; break; case 5: result = ( ( ( -OVER_6*t + 5./12 )*t -0.25 )*t -OVER_12 )*t +OVER_12; break; default: result = 0; } return result; } 690 float d1_c3_1ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( -0.75*t +1.25 )*t + 0 )*t*t + 0 )*t +0; break; case 1: result = ( ( ( 0.75*t + 0 )*t -2.5 )*t*t +1.25 )*t +0.5; break; case 2: result = ( ( ( 0.75*t -3.75 )*t +5 )*t*t -2.5 )*t +0; break; case 3: result = ( ( ( -0.75*t +2.5 )*t -2.5 )*t*t +1.25 )*t -0.5; break; default: result = 0; } return result; } 708 float d1_c3_2ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( 1*t -3 )*t +2.5 )*t*t*t +0 )*t +0; break; case 1: result = ( ( ( -3*t +9 )*t -7.5 )*t*t*t +1 )*t +0.5; break; case 2: result = ( ( ( 3*t -9 )*t +7.5 )*t*t*t -2 )*t +0; break; case 3: result = ( ( ( -1*t +3 )*t -2.5 )*t*t*t +1 )*t -0.5; break; default: result = 0; } return result; } 726 float d1_c3_3ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( ( 3./16*t - 13./48 )*t + 0 )*t + 0 )*t + 0 )*t +0; break; case 1: result = ( ( ( ( -9./16*t + 5./12 )*t +19./24 )*t +0.25 )*t - 7./48 )*t -OVER_12; break; case 2: result = ( ( ( ( 3./8 *t + 25./24 )*t -19./6 )*t - 0.5 )*t +19./12 )*t +OVER_2_3; break; case 3: result = ( ( ( ( 3./8 *t - 35./12 )*t +19./4 )*t + 0 )*t -23./8 )*t +0; break; case 4: result = ( ( ( ( -9./16*t + 115./48 )*t -19./6 )*t + 0.5 )*t +19./12 )*t -OVER_2_3; break; case 5: result = ( ( ( ( 3./16*t -OVER_2_3 )*t +19./24 )*t -0.25 )*t - 7./48 )*t +OVER_12; break; default: result = 0; } return result; } 746 float d1_c3_4ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( ( ( -0.25*t +0.75 )*t - 7./12 )*t + 0 )*t + 0 )*t + 0 )*t +0; break; case 1: result = ( ( ( ( ( 1.25*t -3.75 )*t +35./12 )*t + OVER_6 )*t +0.25 )*t -OVER_12 )*t -OVER_12; break; case 2: result = ( ( ( ( ( -2.5*t + 7.5 )*t -35./6 )*t -OVER_2_3 )*t - 0.5 )*t + 4./3 )*t +OVER_2_3; break; case 3: result = ( ( ( ( ( 2.5*t - 7.5 )*t +35./6 )*t + 1 )*t + 0 )*t - 5./2 )*t +0; break; case 4: result = ( ( ( ( ( -1.25*t +3.75 )*t -35./12 )*t -OVER_2_3 )*t + 0.5 )*t + 4./3 )*t -OVER_2_3; break; case 5: result = ( ( ( ( ( 0.25*t -0.75 )*t + 7./12 )*t + OVER_6 )*t -0.25 )*t -OVER_12 )*t +OVER_12; break; default: result = 0; } return result; } /***************************************************************************/ /* Second Derivative Filters */ /***************************************************************************/ 772 float d2_cn_1ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = 0.5; break; case 1: result = -0.5; break; case 2: result = -0.5; break; case 3: result = 0.5; break; default: result = 0; } return result; } 790 float d2_cn_2ef( float a, float t ) { return d2_c0_2ef( a, t ); } 795 float d2_cn_3ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( 0.25*t +( a-30 )/120 )*t -( a+10 )/240; break; case 1: result = ( -0.75*t -( a-42 )/24 )*t +( a+ 6 )/48; break; case 2: result = ( 0.5 *t +( a-42 )/12 )*t -( a-22 )/24; break; case 3: result = ( 0.5 *t -( a-30 )/12 )*t +( a-50 )/24; break; case 4: result = ( -0.75*t +( a- 6 )/24 )*t -( a-54 )/48; break; case 5: result = ( 0.25*t -( a+30 )/120 )*t +( a-10 )/240; break; default: result = 0; } return result; } 815 float d2_cn_4ef( float a, float t ) { return d2_c0_4ef( a, t ); } 820 float d2_c0_1ef( float a, float t ) { return d2_c0_2ef( a, t ); } 825 float d2_c0_2ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = t; break; case 1: result = -3*t +1; break; case 2: result = 3*t -2; break; case 3: result = - t +1; break; default: result = 0; } return result; } 843 float d2_c0_3ef( float a, float t ) { return d2_cn_3ef( -10, t ); } 848 float d2_c0_4ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( 1./6*t +0 )*t -0.25 )*t + 0; break; case 1: result = ( ( -5./6*t +0.5 )*t +1.75 )*t -1./12; break; case 2: result = ( ( 5./3*t -2 )*t -3.5 )*t + 4./3; break; case 3: result = ( ( -5./3*t +3 )*t +2.5 )*t - 2.5; break; case 4: result = ( ( 5./6*t -2 )*t -0.25 )*t + 4./3; break; case 5: result = ( ( -1./6*t +0.5 )*t -0.25 )*t -1./12; break; default: result = 0; } return result; } 868 float d2_c1_1ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( -2*t +3 )*t*t +0; break; case 1: result = ( 6*t -9 )*t*t +1; break; case 2: result = ( -6*t +9 )*t*t -2; break; case 3: result = ( 2*t -3 )*t*t +1; break; default: result = 0; } return result; } 886 float d2_c1_2ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( 0.25*t +0 )*t; break; case 1: result = ( -0.75*t +0.5 )*t +0.25; break; case 2: result = ( 0.5 *t -1 )*t; break; case 3: result = ( 0.5 *t +0 )*t -0.5; break; case 4: result = ( -0.75*t +1 )*t; break; case 5: result = ( 0.25*t -0.5 )*t +0.25; break; default: result = 0; } return result; } 905 float d2_c1_3ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( 2./3*t - 0.75 )*t +0 )*t; break; case 1: result = ( ( -10./3*t + 4.25 )*t +0.5 )*t -1./12; break; case 2: result = ( ( 20./3*t - 9.5 )*t -1 )*t +4./3; break; case 3: result = ( ( -20./3*t +10.5 )*t +0 )*t -2.5; break; case 4: result = ( ( 10./3*t - 5.75 )*t +1 )*t +4./3; break; case 5: result = ( ( - 2./3*t + 1.25 )*t -0.5 )*t -1./12; break; default: result = 0; } return result; } 925 float d2_c1_4ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( -( a+ 53 )/360*t +( a+ 38 )/240 )*t +0 )*t; break; case 1: result = ( ( ( 7*a+431 )/360*t -( 7*a+296 )/240 )*t - 1./8 )*t +( a+ 8 )/720; break; case 2: result = ( ( -( 7*a+471 )/120*t +( 7*a+366 )/80 )*t +1 )*t -( a+18 )/120; break; case 3: result = ( ( ( 7*a+491 )/72 *t -( 7*a+452 )/48 )*t -13./8 )*t +( a+72 )/48 ; break; case 4: result = ( ( -( 7*a+491 )/72 *t +( 7*a+530 )/48 )*t +0 )*t -( a+98 )/36 ; break; case 5: result = ( ( ( 7*a+471 )/120*t -( 7*a+576 )/80 )*t +13./8 )*t +( a+72 )/48 ; break; case 6: result = ( ( -( 7*a+431 )/360*t +( 7*a+566 )/240 )*t -1 )*t -( a+18 )/120; break; case 7: result = ( ( ( a+ 53 )/360*t -( a+ 68 )/240 )*t + 1./8 )*t +( a+ 8 )/720; break; default: result = 0; } return result; } 947 float d2_c2_1ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( 6*t -15 )*t +10 )*t*t*t; break; case 1: result = ( ( -18*t +45 )*t -30 )*t*t*t +1; break; case 2: result = ( ( 18*t -45 )*t +30 )*t*t*t -2; break; case 3: result = ( ( - 6*t +15 )*t -10 )*t*t*t +1; break; default: result = 0; } return result; } 965 float d2_c2_2ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( 1./6*t +0 )*t +0 )*t; break; case 1: result = ( ( -5./6*t +0.5 )*t +0.5 )*t +1./6; break; case 2: result = ( ( 5./3*t -2 )*t -1 )*t +1./3; break; case 3: result = ( ( -5./3*t +3 )*t +0 )*t -1; break; case 4: result = ( ( 5./6*t -2 )*t +1 )*t +1./3; break; case 5: result = ( ( -1./6*t +0.5 )*t -0.5 )*t +1./6; break; default: result = 0; } return result; } 985 float d2_c2_3ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( ( -1.5*t + 3.75 )*t - 7./3 )*t +0 )*t +0 )*t; break; case 1: result = ( ( ( ( 7.5*t -18.75 )*t +35./3 )*t +0.5 )*t +0.5 )*t -1./12; break; case 2: result = ( ( ( ( - 15*t +37.5 )*t -70./3 )*t -2 )*t -1 )*t +4./3 ; break; case 3: result = ( ( ( ( 15*t -37.5 )*t +70./3 )*t +3 )*t +0 )*t -2.5 ; break; case 4: result = ( ( ( ( -7.5*t +18.75 )*t -35./3 )*t -2 )*t +1 )*t +4./3 ; break; case 5: result = ( ( ( ( 1.5*t - 3.75 )*t + 7./3 )*t +0.5 )*t -0.5 )*t -1./12; break; default: result = 0; } return result; } 1005 float d2_c2_4ef( float a, float t ) { return d2_c1_4ef( -38, t ); } 1010 float d2_c3_1ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( -20*t + 70 )*t - 84 )*t + 35 )*t*t*t*t; break; case 1: result = ( ( ( 60*t -210 )*t +252 )*t -105 )*t*t*t*t +1; break; case 2: result = ( ( ( -60*t +210 )*t -252 )*t +105 )*t*t*t*t -2; break; case 3: result = ( ( ( 20*t - 70 )*t + 84 )*t - 35 )*t*t*t*t +1; break; default: result = 0; } return result; } 1028 float d2_c3_2ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( -0.1*t +0.25 )*t*t + 0 )*t +0 )*t; break; case 1: result = ( ( ( 0.5*t -1.25 )*t*t +0.5 )*t +0.5 )*t +3./20; break; case 2: result = ( ( ( -1 *t +2.5 )*t*t -2 )*t -1 )*t +2./5; break; case 3: result = ( ( ( 1 *t -2.5 )*t*t +3 )*t +0 )*t -11./10; break; case 4: result = ( ( ( -0.5*t +1.25 )*t*t -2 )*t +1 )*t +2./5; break; case 5: result = ( ( ( 0.1*t -0.25 )*t*t +0.5 )*t -0.5 )*t +3./20; break; default: result = 0; } return result; } 1048 float d2_c3_3ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( ( ( 14./3*t - 49./3 )*t + 39./2 )*t - 95./12 )*t*t +0 )*t +0 )*t; break; case 1: result = ( ( ( ( ( - 70./3*t +245./3 )*t -195./2 )*t +475./12 )*t*t +0.5 )*t +0.5 )*t -1./12; break; case 2: result = ( ( ( ( ( 140./3*t -490./3 )*t +195 )*t -475./6 )*t*t -2 )*t -1 )*t +4./3; break; case 3: result = ( ( ( ( ( -140./3*t +490./3 )*t -195 )*t +475./6 )*t*t +3 )*t +0 )*t -5./2; break; case 4: result = ( ( ( ( ( 70./3*t -245./3 )*t +195./2 )*t -475./12 )*t*t -2 )*t +1 )*t +4./3; break; case 5: result = ( ( ( ( ( - 14./3*t + 49./3 )*t - 39./2 )*t + 95./12 )*t*t +0.5 )*t -0.5 )*t -1./12; break; default: result = 0; } return result; } 1068 float d2_c3_4ef( float a, float t ) { float result; int i; i = ( t<0 ) ? ( int )t-1:( int )t; t = t - i; switch ( i ) { case 0: result = ( ( ( ( 1./24*t - 1./12 )*t +0 )*t +0 )*t +0 )*t; break; case 1: result = ( ( ( ( - 7./24*t + 5./8 )*t +1./12 )*t -1./12 )*t - 1./8 )*t - 1./24; break; case 2: result = ( ( ( ( 7./8 *t - 2 )*t -1./3 )*t +1 )*t +1 )*t + 1./6; break; case 3: result = ( ( ( ( -35./24*t +85./24 )*t +5./12 )*t -13./4 )*t -13./8 )*t +17./24; break; case 4: result = ( ( ( ( 35./24*t -15./4 )*t +0 )*t +14./3 )*t +0 )*t - 5./3; break; case 5: result = ( ( ( ( - 7./8 *t +19./8 )*t -5./12 )*t -13./4 )*t +13./8 )*t +17./24; break; case 6: result = ( ( ( ( 7./24*t - 5./6 )*t +1./3 )*t +1 )*t -1 )*t + 1./6; break; case 7: result = ( ( ( ( - 1./24*t + 1./8 )*t -1./12 )*t -1./12 )*t + 1./8 )*t - 1./24; break; default: result = 0; } return result; }

/Users/scm/git/github/teem/src/nrrd/tmfKernel.c

1 /* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2013, 2012, 2011, 2010, 2009 University of Chicago Copyright ( C ) 2008, 2007, 2006, 2005 Gordon Kindlmann Copyright ( C ) 2004, 2003, 2002, 2001, 2000, 1999, 1998 University of Utah This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "nrrd.h" /* ************************************************* */ /* !! WARNING !!! WARNING !!! WARNING !!! WARNING !! */ /* !! WARNING !!! WARNING !!! WARNING !!! WARNING !! */ /* !! WARNING !!! WARNING !!! WARNING !!! WARNING !! */ /* */ /* */ /* THIS FILE AUTOMATICALLY GENERATED FROM */ /* PERL SCRIPTS IN THE tmf SUBDIRECTORY */ /* EDIT THOSE SCRIPTS, NOT THIS FILE! */ /* */ /* */ /* !! WARNING !!! WARNING !!! WARNING !!! WARNING !! */ /* !! WARNING !!! WARNING !!! WARNING !!! WARNING !! */ /* !! WARNING !!! WARNING !!! WARNING !!! WARNING !! */ /* ************************************************* */ static double 43 _nrrd_TMFBAD_Int( const double *parm ) { AIR_UNUSED( parm ); fprintf( stderr, "_nrrd_TMFBAD: Invalid TMF indexing: ef == 0\n" ); return 0.0; } static double 50 _nrrd_TMFBAD_Sup( const double *parm ) { AIR_UNUSED( parm ); fprintf( stderr, "_nrrd_TMFBAD: Invalid TMF indexing: ef == 0\n" ); return 0.0; } static double 57 _nrrd_TMFBAD_1_d( double x, const double *parm ) { AIR_UNUSED( x ); AIR_UNUSED( parm ); fprintf( stderr, "_nrrd_TMFBAD: Invalid TMF indexing: ef == 0\n" ); return 0.0; } static float 65 _nrrd_TMFBAD_1_f( float x, const double *parm ) { AIR_UNUSED( x ); AIR_UNUSED( parm ); fprintf( stderr, "_nrrd_TMFBAD: Invalid TMF indexing: ef == 0\n" ); return 0.0; } static void 73 _nrrd_TMFBAD_N_d( double *f, const double *x, size_t len, const double *parm ) { AIR_UNUSED( f ); AIR_UNUSED( x ); AIR_UNUSED( len ); AIR_UNUSED( parm ); fprintf( stderr, "_nrrd_TMFBAD: Invalid TMF indexing: ef == 0\n" ); } static void 82 _nrrd_TMFBAD_N_f( float *f, const float *x, size_t len, const double *parm ) { AIR_UNUSED( f ); AIR_UNUSED( x ); AIR_UNUSED( len ); AIR_UNUSED( parm ); fprintf( stderr, "_nrrd_TMFBAD: Invalid TMF indexing: ef == 0\n" ); } static NrrdKernel _nrrdKernel_TMFBAD = { "TMFBAD", 1, _nrrd_TMFBAD_Sup, _nrrd_TMFBAD_Int, _nrrd_TMFBAD_1_f, _nrrd_TMFBAD_N_f, _nrrd_TMFBAD_1_d, _nrrd_TMFBAD_N_d }; #define OVER_3 0.33333333 #define OVER_6 0.16666666 #define OVER_12 0.0833333333 #define OVER_2_3 0.6666666666 /* ------------------------ TMF_dn_cn_1ef --------------------- */ #define TMF_dn_cn_1ef( a, i, t ) ( \ ( i == 0 ? 0.5 : \ ( i == 1 ? 0.5 : \ 0 ) ) ) /* ------------------------ TMF_dn_cn_2ef --------------------- */ #define TMF_dn_cn_2ef( a, i, t ) ( \ TMF_d0_c0_2ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_dn_cn_3ef --------------------- */ #define TMF_dn_cn_3ef( a, i, t ) ( \ ( i == 0 ? ( 0.25*t +( 2*a-0.25 ) )*t - a : \ ( i == 1 ? ( -0.25*t -( 6*a-1.25 ) )*t + 3*a : \ ( i == 2 ? ( -0.25*t +( 6*a-0.75 ) )*t - 3*a+1 : \ ( i == 3 ? ( 0.25*t -( 2*a+0.25 ) )*t + a : \ 0 ) ) ) ) ) /* ------------------------ TMF_dn_cn_4ef --------------------- */ #define TMF_dn_cn_4ef( a, i, t ) ( \ TMF_d0_c0_4ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_dn_c0_1ef --------------------- */ #define TMF_dn_c0_1ef( a, i, t ) ( \ TMF_d0_c0_2ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_dn_c0_2ef --------------------- */ #define TMF_dn_c0_2ef( a, i, t ) ( \ TMF_d0_c0_2ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_dn_c0_3ef --------------------- */ #define TMF_dn_c0_3ef( a, i, t ) ( \ TMF_d0_c0_3ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_dn_c0_4ef --------------------- */ #define TMF_dn_c0_4ef( a, i, t ) ( \ TMF_d0_c0_4ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_dn_c1_1ef --------------------- */ #define TMF_dn_c1_1ef( a, i, t ) ( \ TMF_d0_c1_1ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_dn_c1_2ef --------------------- */ #define TMF_dn_c1_2ef( a, i, t ) ( \ ( i == 0 ? ( t )*t/4 : \ ( i == 1 ? ( -t +2 )*t/4 +0.25 : \ ( i == 2 ? ( -t )*t/4 +0.5 : \ ( i == 3 ? ( t -2 )*t/4 +0.25 : \ 0 ) ) ) ) ) /* ------------------------ TMF_dn_c1_3ef --------------------- */ #define TMF_dn_c1_3ef( a, i, t ) ( \ TMF_d0_c1_3ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_dn_c1_4ef --------------------- */ #define TMF_dn_c1_4ef( a, i, t ) ( \ ( i == 0 ? ( ( -( a )*t +( 1.5*a- 1./24 ) )*t + 0 )*t + 0 : \ ( i == 1 ? ( ( ( 5*a+OVER_6 )*t -( 7.5*a- 1./8 ) )*t - ( OVER_12 ) )*t +( 0.5*a-1./24 ) : \ ( i == 2 ? ( ( -( 10*a+ 0.5 )*t +( 15*a+ 5./12 ) )*t +( OVER_2_3 ) )*t -( 2*a-OVER_6 ) : \ ( i == 3 ? ( ( ( 10*a+ 0.5 )*t -( 15*a+13./12 ) )*t + 0 )*t +( 3*a+0.75 ) : \ ( i == 4 ? ( ( -( 5*a+OVER_6 )*t +( 7.5*a+ 5./8 ) )*t -( OVER_2_3 ) )*t -( 2*a-OVER_6 ) : \ ( i == 5 ? ( ( ( a )*t -( 1.5*a+ 1./24 ) )*t + ( OVER_12 ) )*t +( 0.5*a-1./24 ) : \ 0 ) ) ) ) ) ) ) /* ------------------------ TMF_dn_c2_1ef --------------------- */ #define TMF_dn_c2_1ef( a, i, t ) ( \ TMF_d0_c2_1ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_dn_c2_2ef --------------------- */ #define TMF_dn_c2_2ef( a, i, t ) ( \ ( i == 0 ? ( ( OVER_6*t + 0 )*t + 0 )*t + 0 : \ ( i == 1 ? ( ( -0.5*t +0.5 )*t +0.5 )*t + OVER_6 : \ ( i == 2 ? ( ( 0.5*t - 1 )*t + 0 )*t +OVER_2_3 : \ ( i == 3 ? ( ( -OVER_6*t +0.5 )*t -0.5 )*t + OVER_6 : \ 0 ) ) ) ) ) /* ------------------------ TMF_dn_c2_3ef --------------------- */ #define TMF_dn_c2_3ef( a, i, t ) ( \ TMF_d0_c2_3ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_dn_c2_4ef --------------------- */ #define TMF_dn_c2_4ef( a, i, t ) ( \ TMF_dn_c1_4ef( ( double )( 1./36 ), i, t ) ) /* ------------------------ TMF_dn_c3_1ef --------------------- */ #define TMF_dn_c3_1ef( a, i, t ) ( \ TMF_d0_c3_1ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_dn_c3_2ef --------------------- */ #define TMF_dn_c3_2ef( a, i, t ) ( \ ( i == 0 ? ( -0.10*t +0.25 )*t*t*t*t : \ ( i == 1 ? ( ( ( 0.30*t -0.75 )*t*t +0.5 )*t +0.5 )*t +0.15 : \ ( i == 2 ? ( ( ( -0.30*t +0.75 )*t*t -1 )*t +0 )*t +0.70 : \ ( i == 3 ? ( ( ( 0.10*t -0.25 )*t*t +0.5 )*t -0.5 )*t +0.15 : \ 0 ) ) ) ) ) /* ------------------------ TMF_dn_c3_3ef --------------------- */ #define TMF_dn_c3_3ef( a, i, t ) ( \ TMF_d0_c3_3ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_dn_c3_4ef --------------------- */ #define TMF_dn_c3_4ef( a, i, t ) ( \ ( i == 0 ? ( ( ( ( 1./30*t - 1./16 )*t + 0 )*t + 0 )*t + 0 )*t + 0 : \ ( i == 1 ? ( ( ( ( -OVER_6*t +17./48 )*t +OVER_12 )*t - 1./24 )*t - OVER_12 )*t - 7./240 : \ ( i == 2 ? ( ( ( ( OVER_3*t -19./24 )*t -OVER_6 )*t +OVER_2_3 )*t +OVER_2_3 )*t + 7./60 : \ ( i == 3 ? ( ( ( ( -OVER_3*t + 7./8 )*t + 0 )*t - 1.25 )*t + 0 )*t +33./40 : \ ( i == 4 ? ( ( ( ( OVER_6*t -23./48 )*t +OVER_6 )*t +OVER_2_3 )*t -OVER_2_3 )*t + 7./60 : \ ( i == 5 ? ( ( ( ( - 1./30*t + 5./48 )*t -OVER_12 )*t - 1./24 )*t + OVER_12 )*t - 7./240 : \ 0 ) ) ) ) ) ) ) /* ------------------------ TMF_d0_cn_1ef --------------------- */ #define TMF_d0_cn_1ef( a, i, t ) ( \ TMF_d0_c0_2ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_d0_cn_2ef --------------------- */ #define TMF_d0_cn_2ef( a, i, t ) ( \ TMF_d0_c0_2ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_d0_cn_3ef --------------------- */ #define TMF_d0_cn_3ef( a, i, t ) ( \ TMF_d0_c0_3ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_d0_cn_4ef --------------------- */ #define TMF_d0_cn_4ef( a, i, t ) ( \ TMF_d0_c0_4ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_d0_c0_1ef --------------------- */ #define TMF_d0_c0_1ef( a, i, t ) ( \ TMF_d0_c0_2ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_d0_c0_2ef --------------------- */ #define TMF_d0_c0_2ef( a, i, t ) ( \ ( i == 0 ? t : \ ( i == 1 ? 1-t : \ 0 ) ) ) /* ------------------------ TMF_d0_c0_3ef --------------------- */ #define TMF_d0_c0_3ef( a, i, t ) ( \ TMF_dn_cn_3ef( ( double )( 0 ), i, t ) ) /* ------------------------ TMF_d0_c0_4ef --------------------- */ #define TMF_d0_c0_4ef( a, i, t ) ( \ ( i == 0 ? ( ( OVER_6*t +0 )*t -OVER_6 )*t : \ ( i == 1 ? ( ( -0.5*t +0.5 )*t +1 )*t : \ ( i == 2 ? ( ( 0.5*t -1 )*t -0.5 )*t+1 : \ ( i == 3 ? ( ( -OVER_6*t +0.5 )*t -OVER_3 )*t : \ 0 ) ) ) ) ) /* ------------------------ TMF_d0_c1_1ef --------------------- */ #define TMF_d0_c1_1ef( a, i, t ) ( \ ( i == 0 ? ( -2*t +3 )*t*t : \ ( i == 1 ? ( 2*t -3 )*t*t +1 : \ 0 ) ) ) /* ------------------------ TMF_d0_c1_2ef --------------------- */ #define TMF_d0_c1_2ef( a, i, t ) ( \ TMF_d0_c1_3ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_d0_c1_3ef --------------------- */ #define TMF_d0_c1_3ef( a, i, t ) ( \ ( i == 0 ? ( ( 0.5*t -0.5 )*t +0 )*t : \ ( i == 1 ? ( ( -1.5*t +2 )*t +0.5 )*t : \ ( i == 2 ? ( ( 1.5*t -2.5 )*t +0 )*t +1 : \ ( i == 3 ? ( ( -0.5*t +1 )*t -0.5 )*t : \ 0 ) ) ) ) ) /* ------------------------ TMF_d0_c1_4ef --------------------- */ #define TMF_d0_c1_4ef( a, i, t ) ( \ TMF_dn_c1_4ef( ( double )( 1./12 ), i, t ) ) /* ------------------------ TMF_d0_c2_1ef --------------------- */ #define TMF_d0_c2_1ef( a, i, t ) ( \ ( i == 0 ? ( ( 6*t -15 )*t +10 )*t*t*t : \ ( i == 1 ? ( ( -6*t +15 )*t -10 )*t*t*t +1 : \ 0 ) ) ) /* ------------------------ TMF_d0_c2_2ef --------------------- */ #define TMF_d0_c2_2ef( a, i, t ) ( \ ( i == 0 ? ( ( ( 0.5*t -0.5 )*t + 0 )*t + 0 )*t : \ ( i == 1 ? ( ( ( -0.5*t -0.5 )*t +1.5 )*t +0.5 )*t : \ ( i == 2 ? ( ( ( -0.5*t +2.5 )*t - 3 )*t + 0 )*t +1 : \ ( i == 3 ? ( ( ( 0.5*t -1.5 )*t +1.5 )*t -0.5 )*t : \ 0 ) ) ) ) ) /* ------------------------ TMF_d0_c2_3ef --------------------- */ #define TMF_d0_c2_3ef( a, i, t ) ( \ ( i == 0 ? ( ( ( ( -1*t +2.5 )*t -1.5 )*t +0 )*t +0 )*t : \ ( i == 1 ? ( ( ( ( 3*t -7.5 )*t +4.5 )*t +0.5 )*t +0.5 )*t : \ ( i == 2 ? ( ( ( ( -3*t +7.5 )*t -4.5 )*t -1 )*t +0 )*t +1 : \ ( i == 3 ? ( ( ( ( 1*t -2.5 )*t +1.5 )*t +0.5 )*t -0.5 )*t : \ 0 ) ) ) ) ) /* ------------------------ TMF_d0_c2_4ef --------------------- */ #define TMF_d0_c2_4ef( a, i, t ) ( \ ( i == 0 ? ( ( ( -1./12*t + 1./12 )*t + 0 )*t + 0 )*t : \ ( i == 1 ? ( ( ( 1./4 *t + 1./12 )*t -1./4 )*t - OVER_12 )*t : \ ( i == 2 ? ( ( ( -1./6 *t - 1 )*t +3./2 )*t +OVER_2_3 )*t : \ ( i == 3 ? ( ( ( -1./6 *t + 5./3 )*t -5./2 )*t + 0 )*t +1 : \ ( i == 4 ? ( ( ( 1./4 *t -13./12 )*t +3./2 )*t -OVER_2_3 )*t : \ ( i == 5 ? ( ( ( -1./12*t + 1./4 )*t -1./4 )*t + OVER_12 )*t : \ 0 ) ) ) ) ) ) ) /* ------------------------ TMF_d0_c3_1ef --------------------- */ #define TMF_d0_c3_1ef( a, i, t ) ( \ ( i == 0 ? ( ( ( -20*t +70 )*t -84 )*t +35 )*t*t*t*t : \ ( i == 1 ? ( ( ( 20*t -70 )*t +84 )*t -35 )*t*t*t*t +1 : \ 0 ) ) ) /* ------------------------ TMF_d0_c3_2ef --------------------- */ #define TMF_d0_c3_2ef( a, i, t ) ( \ TMF_d0_c3_3ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_d0_c3_3ef --------------------- */ #define TMF_d0_c3_3ef( a, i, t ) ( \ ( i == 0 ? ( ( ( ( ( 3*t -10.5 )*t +12.5 )*t - 5 )*t*t +0 )*t +0 )*t : \ ( i == 1 ? ( ( ( ( ( -9*t +31.5 )*t -37.5 )*t +15 )*t*t +0.5 )*t +0.5 )*t : \ ( i == 2 ? ( ( ( ( ( 9*t -31.5 )*t +37.5 )*t -15 )*t*t -1 )*t +0 )*t +1 : \ ( i == 3 ? ( ( ( ( ( -3*t +10.5 )*t -12.5 )*t + 5 )*t*t +0.5 )*t -0.5 )*t : \ 0 ) ) ) ) ) /* ------------------------ TMF_d0_c3_4ef --------------------- */ #define TMF_d0_c3_4ef( a, i, t ) ( \ ( i == 0 ? ( ( ( ( ( 7./48*t - 3./8 )*t +11./48 )*t +0 )*t + 0 )*t + 0 )*t : \ ( i == 1 ? ( ( ( ( ( -7./16*t + 1 )*t - 3./8 )*t +1./12 )*t - 3./16 )*t - OVER_12 )*t : \ ( i == 2 ? ( ( ( ( ( 7./24*t - 1./4 )*t -19./24 )*t -1./6 )*t + 5./4 )*t +OVER_2_3 )*t : \ ( i == 3 ? ( ( ( ( ( 7./24*t - 3./2 )*t + 7./3 )*t +0 )*t -17./8 )*t + 0 )*t +1 : \ ( i == 4 ? ( ( ( ( ( -7./16*t +13./8 )*t -31./16 )*t +1./6 )*t + 5./4 )*t -OVER_2_3 )*t : \ ( i == 5 ? ( ( ( ( ( 7./48*t - 1./2 )*t +13./24 )*t -1./12 )*t - 3./16 )*t + OVER_12 )*t : \ 0 ) ) ) ) ) ) ) /* ------------------------ TMF_d1_cn_1ef --------------------- */ #define TMF_d1_cn_1ef( a, i, t ) ( \ ( i == 0 ? 1 : \ ( i == 1 ? -1 : \ 0 ) ) ) /* ------------------------ TMF_d1_cn_2ef --------------------- */ #define TMF_d1_cn_2ef( a, i, t ) ( \ ( i == 0 ? 0.5*t +( a ) : \ ( i == 1 ? -0.5*t -( 3*a-0.5 ) : \ ( i == 2 ? -0.5*t +( 3*a ) : \ ( i == 3 ? 0.5*t -( a+0.5 ) : \ 0 ) ) ) ) ) /* ------------------------ TMF_d1_cn_3ef --------------------- */ #define TMF_d1_cn_3ef( a, i, t ) ( \ ( i == 0 ? ( 0.5*t +0 )*t -OVER_6 : \ ( i == 1 ? ( -1.5*t +1 )*t +1 : \ ( i == 2 ? ( 1.5*t -2 )*t -0.5 : \ ( i == 3 ? ( -0.5*t +1 )*t -OVER_3 : \ 0 ) ) ) ) ) /* ------------------------ TMF_d1_cn_4ef --------------------- */ #define TMF_d1_cn_4ef( a, i, t ) ( \ TMF_d1_c0_4ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_d1_c0_1ef --------------------- */ #define TMF_d1_c0_1ef( a, i, t ) ( \ TMF_d1_c0_2ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_d1_c0_2ef --------------------- */ #define TMF_d1_c0_2ef( a, i, t ) ( \ TMF_d1_cn_2ef( ( double )( 0 ), i, t ) ) /* ------------------------ TMF_d1_c0_3ef --------------------- */ #define TMF_d1_c0_3ef( a, i, t ) ( \ ( i == 0 ? ( ( a )*t -( a+OVER_12 ) )*t +0 : \ ( i == 1 ? ( -( 5*a-0.5 )*t +( 5*a+ 0.25 ) )*t -OVER_12 : \ ( i == 2 ? ( ( 10*a-1.5 )*t -( 10*a- 5./6 ) )*t +OVER_2_3 : \ ( i == 3 ? ( -( 10*a-1.5 )*t +( 10*a- 13./6 ) )*t +0 : \ ( i == 4 ? ( ( 5*a-0.5 )*t -( 5*a- 1.25 ) )*t -OVER_2_3 : \ ( i == 5 ? ( -( a )*t +( a-OVER_12 ) )*t +OVER_12 : \ 0 ) ) ) ) ) ) ) /* ------------------------ TMF_d1_c0_4ef --------------------- */ #define TMF_d1_c0_4ef( a, i, t ) ( \ ( i == 0 ? ( ( OVER_12*t +( a ) )*t -( a+ OVER_6 ) )*t +0 : \ ( i == 1 ? ( ( -0.25*t -( 5*a-0.25 ) )*t +( 5*a+ 0.75 ) )*t -OVER_12 : \ ( i == 2 ? ( ( OVER_6*t +( 10*a- 0.5 ) )*t -( 10*a+ OVER_3 ) )*t +OVER_2_3 : \ ( i == 3 ? ( ( OVER_6*t -( 10*a ) )*t +( 10*a- 5./6 ) )*t +0 : \ ( i == 4 ? ( ( -0.25*t +( 5*a+ 0.5 ) )*t -( 5*a- 0.5 ) )*t -OVER_2_3 : \ ( i == 5 ? ( ( OVER_12*t -( a+0.25 ) )*t +( a+OVER_12 ) )*t +OVER_12 : \ 0 ) ) ) ) ) ) ) /* ------------------------ TMF_d1_c1_1ef --------------------- */ #define TMF_d1_c1_1ef( a, i, t ) ( \ TMF_d1_c1_2ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_d1_c1_2ef --------------------- */ #define TMF_d1_c1_2ef( a, i, t ) ( \ ( i == 0 ? ( 0.5*t +0 )*t +0 : \ ( i == 1 ? ( -1.5*t +1 )*t +0.5 : \ ( i == 2 ? ( 1.5*t -2 )*t +0 : \ ( i == 3 ? ( -0.5*t +1 )*t -0.5 : \ 0 ) ) ) ) ) /* ------------------------ TMF_d1_c1_3ef --------------------- */ #define TMF_d1_c1_3ef( a, i, t ) ( \ TMF_d1_c0_3ef( ( double )( -1./12 ), i, t ) ) 504 /* ------------------------ TMF_d1_c1_4ef --------------------- */ #define TMF_d1_c1_4ef( a, i, t ) ( \ TMF_d1_c0_4ef( ( double )( -1./6 ), i, t ) ) 509 /* ------------------------ TMF_d1_c2_1ef --------------------- */ #define TMF_d1_c2_1ef( a, i, t ) ( \ TMF_d1_c2_2ef( ( double )( a ), i, t ) ) 515 /* ------------------------ TMF_d1_c2_2ef --------------------- */ #define TMF_d1_c2_2ef( a, i, t ) ( \ ( i == 0 ? ( ( -0.5*t +1 )*t*t +0 )*t +0 : \ ( i == 1 ? ( ( 1.5*t -3 )*t*t +1 )*t +0.5 : \ ( i == 2 ? ( ( -1.5*t +3 )*t*t -2 )*t +0 : \ ( i == 3 ? ( ( 0.5*t -1 )*t*t +1 )*t -0.5 : \ 0 ) ) ) ) ) 526 /* ------------------------ TMF_d1_c2_3ef --------------------- */ #define TMF_d1_c2_3ef( a, i, t ) ( \ TMF_d1_c2_4ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_d1_c2_4ef --------------------- */ #define TMF_d1_c2_4ef( a, i, t ) ( \ ( i == 0 ? ( ( ( OVER_6*t - 0.25 )*t + 0 )*t + 0 )*t +0 : \ ( i == 1 ? ( ( ( - 5./6*t +17./12 )*t +0.25 )*t -OVER_12 )*t -OVER_12 : \ 537 ( i == 2 ? ( ( ( 5./3*t - 19./6 )*t -0.5 )*t + 4./3 )*t +OVER_2_3 : \ ( i == 3 ? ( ( ( - 5./3*t + 3.5 )*t +0 )*t - 2.5 )*t +0 : \ ( i == 4 ? ( ( ( 5./6*t -23./12 )*t +0.5 )*t + 4./3 )*t -OVER_2_3 : \ ( i == 5 ? ( ( ( -OVER_6*t + 5./12 )*t -0.25 )*t -OVER_12 )*t +OVER_12 : \ 0 ) ) ) ) ) ) ) /* ------------------------ TMF_d1_c3_1ef --------------------- */ #define TMF_d1_c3_1ef( a, i, t ) ( \ ( i == 0 ? ( ( ( -0.75*t +1.25 )*t + 0 )*t*t + 0 )*t +0 : \ ( i == 1 ? ( ( ( 0.75*t + 0 )*t -2.5 )*t*t +1.25 )*t +0.5 : \ ( i == 2 ? ( ( ( 0.75*t -3.75 )*t +5 )*t*t -2.5 )*t +0 : \ ( i == 3 ? ( ( ( -0.75*t +2.5 )*t -2.5 )*t*t +1.25 )*t -0.5 : \ 0 ) ) ) ) ) 552 /* ------------------------ TMF_d1_c3_2ef --------------------- */ #define TMF_d1_c3_2ef( a, i, t ) ( \ ( i == 0 ? ( ( ( 1*t -3 )*t +2.5 )*t*t*t +0 )*t +0 : \ ( i == 1 ? ( ( ( -3*t +9 )*t -7.5 )*t*t*t +1 )*t +0.5 : \ ( i == 2 ? ( ( ( 3*t -9 )*t +7.5 )*t*t*t -2 )*t +0 : \ ( i == 3 ? ( ( ( -1*t +3 )*t -2.5 )*t*t*t +1 )*t -0.5 : \ 0 ) ) ) ) ) /* ------------------------ TMF_d1_c3_3ef --------------------- */ #define TMF_d1_c3_3ef( a, i, t ) ( \ ( i == 0 ? ( ( ( ( 3./16*t - 13./48 )*t + 0 )*t + 0 )*t + 0 )*t +0 : \ ( i == 1 ? ( ( ( ( -9./16*t + 5./12 )*t +19./24 )*t +0.25 )*t - 7./48 )*t -OVER_12 : \ ( i == 2 ? ( ( ( ( 3./8 *t + 25./24 )*t -19./6 )*t - 0.5 )*t +19./12 )*t +OVER_2_3 : \ ( i == 3 ? ( ( ( ( 3./8 *t - 35./12 )*t +19./4 )*t + 0 )*t -23./8 )*t +0 : \ ( i == 4 ? ( ( ( ( -9./16*t + 115./48 )*t -19./6 )*t + 0.5 )*t +19./12 )*t -OVER_2_3 : \ ( i == 5 ? ( ( ( ( 3./16*t -OVER_2_3 )*t +19./24 )*t -0.25 )*t - 7./48 )*t +OVER_12 : \ 0 ) ) ) ) ) ) ) /* ------------------------ TMF_d1_c3_4ef --------------------- */ 577 #define TMF_d1_c3_4ef( a, i, t ) ( \ ( i == 0 ? ( ( ( ( ( -0.25*t +0.75 )*t - 7./12 )*t + 0 )*t + 0 )*t + 0 )*t +0 : \ ( i == 1 ? ( ( ( ( ( 1.25*t -3.75 )*t +35./12 )*t + OVER_6 )*t +0.25 )*t -OVER_12 )*t -OVER_12 : \ ( i == 2 ? ( ( ( ( ( -2.5*t + 7.5 )*t -35./6 )*t -OVER_2_3 )*t - 0.5 )*t + 4./3 )*t +OVER_2_3 : \ 582 ( i == 3 ? ( ( ( ( ( 2.5*t - 7.5 )*t +35./6 )*t + 1 )*t + 0 )*t - 5./2 )*t +0 : \ ( i == 4 ? ( ( ( ( ( -1.25*t +3.75 )*t -35./12 )*t -OVER_2_3 )*t + 0.5 )*t + 4./3 )*t -OVER_2_3 : \ ( i == 5 ? ( ( ( ( ( 0.25*t -0.75 )*t + 7./12 )*t + OVER_6 )*t -0.25 )*t -OVER_12 )*t +OVER_12 : \ 0 ) ) ) ) ) ) ) 588 /* ------------------------ TMF_d2_cn_1ef --------------------- */ #define TMF_d2_cn_1ef( a, i, t ) ( \ ( i == 0 ? 0.5 : \ ( i == 1 ? -0.5 : \ ( i == 2 ? -0.5 : \ ( i == 3 ? 0.5 : \ 0 ) ) ) ) ) /* ------------------------ TMF_d2_cn_2ef --------------------- */ 599 #define TMF_d2_cn_2ef( a, i, t ) ( \ TMF_d2_c0_2ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_d2_cn_3ef --------------------- */ #define TMF_d2_cn_3ef( a, i, t ) ( \ ( i == 0 ? ( 0.25*t +( a-30 )/120 )*t -( a+10 )/240 : \ ( i == 1 ? ( -0.75*t -( a-42 )/24 )*t +( a+ 6 )/48 : \ ( i == 2 ? ( 0.5 *t +( a-42 )/12 )*t -( a-22 )/24 : \ 610 ( i == 3 ? ( 0.5 *t -( a-30 )/12 )*t +( a-50 )/24 : \ ( i == 4 ? ( -0.75*t +( a- 6 )/24 )*t -( a-54 )/48 : \ ( i == 5 ? ( 0.25*t -( a+30 )/120 )*t +( a-10 )/240 : \ 0 ) ) ) ) ) ) ) /* ------------------------ TMF_d2_cn_4ef --------------------- */ #define TMF_d2_cn_4ef( a, i, t ) ( \ TMF_d2_c0_4ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_d2_c0_1ef --------------------- */ #define TMF_d2_c0_1ef( a, i, t ) ( \ 625 TMF_d2_c0_2ef( ( double )( a ), i, t ) ) /* ------------------------ TMF_d2_c0_2ef --------------------- */ #define TMF_d2_c0_2ef( a, i, t ) ( \ ( i == 0 ? t : \ ( i == 1 ? -3*t +1 : \ ( i == 2 ? 3*t -2 : \ ( i == 3 ? - t +1 : \ 0 ) ) ) ) ) /* ------------------------ TMF_d2_c0_3ef --------------------- */ #define TMF_d2_c0_3ef( a, i, t ) ( \ TMF_d2_cn_3ef( ( double )( -10 ), i, t ) ) /* ------------------------ TMF_d2_c0_4ef --------------------- */ #define TMF_d2_c0_4ef( a, i, t ) ( \ ( i == 0 ? ( ( 1./6*t +0 )*t -0.25 )*t + 0 : \ ( i == 1 ? ( ( -5./6*t +0.5 )*t +1.75 )*t -1./12 : \ ( i == 2 ? ( ( 5./3*t -2 )*t -3.5 )*t + 4./3 : \ 650 ( i == 3 ? ( ( -5./3*t +3 )*t +2.5 )*t - 2.5 : \ ( i == 4 ? ( ( 5./6*t -2 )*t -0.25 )*t + 4./3 : \ ( i == 5 ? ( ( -1./6*t +0.5 )*t -0.25 )*t -1./12 : \ 0 ) ) ) ) ) ) ) 655 /* ------------------------ TMF_d2_c1_1ef --------------------- */ #define TMF_d2_c1_1ef( a, i, t ) ( \ ( i == 0 ? ( -2*t +3 )*t*t +0 : \ ( i == 1 ? ( 6*t -9 )*t*t +1 : \ 661 ( i == 2 ? ( -6*t +9 )*t*t -2 : \ ( i == 3 ? ( 2*t -3 )*t*t +1 : \ 0 ) ) ) ) ) /* ------------------------ TMF_d2_c1_2ef --------------------- */ #define TMF_d2_c1_2ef( a, i, t ) ( \ ( i == 0 ? ( 0.25*t +0 )*t : \ ( i == 1 ? ( -0.75*t +0.5 )*t +0.25 : \ ( i == 2 ? ( 0.5 *t -1 )*t : \ 672 ( i == 3 ? ( 0.5 *t +0 )*t -0.5 : \ ( i == 4 ? ( -0.75*t +1 )*t : \ ( i == 5 ? ( 0.25*t -0.5 )*t +0.25 : \ 0 ) ) ) ) ) ) ) /* ------------------------ TMF_d2_c1_3ef --------------------- */ #define TMF_d2_c1_3ef( a, i, t ) ( \ ( i == 0 ? ( ( 2./3*t - 0.75 )*t +0 )*t : \ ( i == 1 ? ( ( -10./3*t + 4.25 )*t +0.5 )*t -1./12 : \ 683 ( i == 2 ? ( ( 20./3*t - 9.5 )*t -1 )*t +4./3 : \ ( i == 3 ? ( ( -20./3*t +10.5 )*t +0 )*t -2.5 : \ ( i == 4 ? ( ( 10./3*t - 5.75 )*t +1 )*t +4./3 : \ ( i == 5 ? ( ( - 2./3*t + 1.25 )*t -0.5 )*t -1./12 : \ 0 ) ) ) ) ) ) ) /* ------------------------ TMF_d2_c1_4ef --------------------- */ #define TMF_d2_c1_4ef( a, i, t ) ( \ ( i == 0 ? ( ( -( a+ 53 )/360*t +( a+ 38 )/240 )*t +0 )*t : \ ( i == 1 ? ( ( ( 7*a+431 )/360*t -( 7*a+296 )/240 )*t - 1./8 )*t +( a+ 8 )/720 : \ ( i == 2 ? ( ( -( 7*a+471 )/120*t +( 7*a+366 )/80 )*t +1 )*t -( a+18 )/120 : \ ( i == 3 ? ( ( ( 7*a+491 )/72 *t -( 7*a+452 )/48 )*t -13./8 )*t +( a+72 )/48 : \ ( i == 4 ? ( ( -( 7*a+491 )/72 *t +( 7*a+530 )/48 )*t +0 )*t -( a+98 )/36 : \ 698 ( i == 5 ? ( ( ( 7*a+471 )/120*t -( 7*a+576 )/80 )*t +13./8 )*t +( a+72 )/48 : \ ( i == 6 ? ( ( -( 7*a+431 )/360*t +( 7*a+566 )/240 )*t -1 )*t -( a+18 )/120 : \ ( i == 7 ? ( ( ( a+ 53 )/360*t -( a+ 68 )/240 )*t + 1./8 )*t +( a+ 8 )/720 : \ 0 ) ) ) ) ) ) ) ) ) /* ------------------------ TMF_d2_c2_1ef --------------------- */ #define TMF_d2_c2_1ef( a, i, t ) ( \ ( i == 0 ? ( ( 6*t -15 )*t +10 )*t*t*t : \ ( i == 1 ? ( ( -18*t +45 )*t -30 )*t*t*t +1 : \ ( i == 2 ? ( ( 18*t -45 )*t +30 )*t*t*t -2 : \ ( i == 3 ? ( ( - 6*t +15 )*t -10 )*t*t*t +1 : \ 0 ) ) ) ) ) /* ------------------------ TMF_d2_c2_2ef --------------------- */ #define TMF_d2_c2_2ef( a, i, t ) ( \ ( i == 0 ? ( ( 1./6*t +0 )*t +0 )*t : \ ( i == 1 ? ( ( -5./6*t +0.5 )*t +0.5 )*t +1./6 : \ ( i == 2 ? ( ( 5./3*t -2 )*t -1 )*t +1./3 : \ ( i == 3 ? ( ( -5./3*t +3 )*t +0 )*t -1 : \ ( i == 4 ? ( ( 5./6*t -2 )*t +1 )*t +1./3 : \ ( i == 5 ? ( ( -1./6*t +0.5 )*t -0.5 )*t +1./6 : \ 723 0 ) ) ) ) ) ) ) /* ------------------------ TMF_d2_c2_3ef --------------------- */ 728 #define TMF_d2_c2_3ef( a, i, t ) ( \ ( i == 0 ? ( ( ( ( -1.5*t + 3.75 )*t - 7./3 )*t +0 )*t +0 )*t : \ ( i == 1 ? ( ( ( ( 7.5*t -18.75 )*t +35./3 )*t +0.5 )*t +0.5 )*t -1./12 : \ ( i == 2 ? ( ( ( ( - 15*t +37.5 )*t -70./3 )*t -2 )*t -1 )*t +4./3 : \ ( i == 3 ? ( ( ( ( 15*t -37.5 )*t +70./3 )*t +3 )*t +0 )*t -2.5 : \ ( i == 4 ? ( ( ( ( -7.5*t +18.75 )*t -35./3 )*t -2 )*t +1 )*t +4./3 : \ 734 ( i == 5 ? ( ( ( ( 1.5*t - 3.75 )*t + 7./3 )*t +0.5 )*t -0.5 )*t -1./12 : \ 0 ) ) ) ) ) ) ) /* ------------------------ TMF_d2_c2_4ef --------------------- */ #define TMF_d2_c2_4ef( a, i, t ) ( \ TMF_d2_c1_4ef( ( double )( -38 ), i, t ) ) /* ------------------------ TMF_d2_c3_1ef --------------------- */ 745 #define TMF_d2_c3_1ef( a, i, t ) ( \ ( i == 0 ? ( ( ( -20*t + 70 )*t - 84 )*t + 35 )*t*t*t*t : \ ( i == 1 ? ( ( ( 60*t -210 )*t +252 )*t -105 )*t*t*t*t +1 : \ ( i == 2 ? ( ( ( -60*t +210 )*t -252 )*t +105 )*t*t*t*t -2 : \ ( i == 3 ? ( ( ( 20*t - 70 )*t + 84 )*t - 35 )*t*t*t*t +1 : \ 0 ) ) ) ) ) /* ------------------------ TMF_d2_c3_2ef --------------------- */ 756 #define TMF_d2_c3_2ef( a, i, t ) ( \ ( i == 0 ? ( ( ( -0.1*t +0.25 )*t*t + 0 )*t +0 )*t : \ ( i == 1 ? ( ( ( 0.5*t -1.25 )*t*t +0.5 )*t +0.5 )*t +3./20 : \ ( i == 2 ? ( ( ( -1 *t +2.5 )*t*t -2 )*t -1 )*t +2./5 : \ ( i == 3 ? ( ( ( 1 *t -2.5 )*t*t +3 )*t +0 )*t -11./10 : \ ( i == 4 ? ( ( ( -0.5*t +1.25 )*t*t -2 )*t +1 )*t +2./5 : \ ( i == 5 ? ( ( ( 0.1*t -0.25 )*t*t +0.5 )*t -0.5 )*t +3./20 : \ 0 ) ) ) ) ) ) ) /* ------------------------ TMF_d2_c3_3ef --------------------- */ #define TMF_d2_c3_3ef( a, i, t ) ( \ ( i == 0 ? ( ( ( ( ( 14./3*t - 49./3 )*t + 39./2 )*t - 95./12 )*t*t +0 )*t +0 )*t : \ ( i == 1 ? ( ( ( ( ( - 70./3*t +245./3 )*t -195./2 )*t +475./12 )*t*t +0.5 )*t +0.5 )*t -1./12 : \ 771 ( i == 2 ? ( ( ( ( ( 140./3*t -490./3 )*t +195 )*t -475./6 )*t*t -2 )*t -1 )*t +4./3 : \ ( i == 3 ? ( ( ( ( ( -140./3*t +490./3 )*t -195 )*t +475./6 )*t*t +3 )*t +0 )*t -5./2 : \ ( i == 4 ? ( ( ( ( ( 70./3*t -245./3 )*t +195./2 )*t -475./12 )*t*t -2 )*t +1 )*t +4./3 : \ ( i == 5 ? ( ( ( ( ( - 14./3*t + 49./3 )*t - 39./2 )*t + 95./12 )*t*t +0.5 )*t -0.5 )*t -1./12 : \ 0 ) ) ) ) ) ) ) /* ------------------------ TMF_d2_c3_4ef --------------------- */ #define TMF_d2_c3_4ef( a, i, t ) ( \ ( i == 0 ? ( ( ( ( 1./24*t - 1./12 )*t +0 )*t +0 )*t +0 )*t : \ ( i == 1 ? ( ( ( ( - 7./24*t + 5./8 )*t +1./12 )*t -1./12 )*t - 1./8 )*t - 1./24 : \ ( i == 2 ? ( ( ( ( 7./8 *t - 2 )*t -1./3 )*t +1 )*t +1 )*t + 1./6 : \ ( i == 3 ? ( ( ( ( -35./24*t +85./24 )*t +5./12 )*t -13./4 )*t -13./8 )*t +17./24 : \ ( i == 4 ? ( ( ( ( 35./24*t -15./4 )*t +0 )*t +14./3 )*t +0 )*t - 5./3 : \ ( i == 5 ? ( ( ( ( - 7./8 *t +19./8 )*t -5./12 )*t -13./4 )*t +13./8 )*t +17./24 : \ ( i == 6 ? ( ( ( ( 7./24*t - 5./6 )*t +1./3 )*t +1 )*t -1 )*t + 1./6 : \ ( i == 7 ? ( ( ( ( - 1./24*t + 1./8 )*t -1./12 )*t -1./12 )*t + 1./8 )*t - 1./24 : \ 0 ) ) ) ) ) ) ) ) ) /* ------------------------ TMF_dn_cn_1ef --------------------- */ static double _nrrd_TMF_dn_cn_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 796 return 1.0; } static double _nrrd_TMF_dn_cn_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 801 return 1; } static double _nrrd_TMF_dn_cn_1ef_1_d( double x, const double *parm ) { int i; 807 AIR_UNUSED( parm ); /* TMF_dn_cn_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_cn_1ef( parm[0], i, x ); } static float _nrrd_TMF_dn_cn_1ef_1_f( float x, const double *parm ) { int i; 818 AIR_UNUSED( parm ); /* TMF_dn_cn_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_cn_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_cn_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 829 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_cn_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_cn_1ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_cn_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 844 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_cn_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_cn_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_cn_1ef = { "TMF_dn_cn_1ef", 1, _nrrd_TMF_dn_cn_1ef_Sup, _nrrd_TMF_dn_cn_1ef_Int, _nrrd_TMF_dn_cn_1ef_1_f, _nrrd_TMF_dn_cn_1ef_N_f, _nrrd_TMF_dn_cn_1ef_1_d, _nrrd_TMF_dn_cn_1ef_N_d }; /* ------------------------ TMF_dn_cn_2ef --------------------- */ static double _nrrd_TMF_dn_cn_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 869 return 1.0; } static double _nrrd_TMF_dn_cn_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 874 return 1; } static double _nrrd_TMF_dn_cn_2ef_1_d( double x, const double *parm ) { int i; 880 AIR_UNUSED( parm ); /* TMF_dn_cn_2ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_cn_2ef( parm[0], i, x ); } static float _nrrd_TMF_dn_cn_2ef_1_f( float x, const double *parm ) { int i; 891 AIR_UNUSED( parm ); /* TMF_dn_cn_2ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_cn_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_cn_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 902 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_cn_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_cn_2ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_cn_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 917 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_cn_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_cn_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_cn_2ef = { "TMF_dn_cn_2ef", 1, _nrrd_TMF_dn_cn_2ef_Sup, _nrrd_TMF_dn_cn_2ef_Int, _nrrd_TMF_dn_cn_2ef_1_f, _nrrd_TMF_dn_cn_2ef_N_f, _nrrd_TMF_dn_cn_2ef_1_d, _nrrd_TMF_dn_cn_2ef_N_d }; /* ------------------------ TMF_dn_cn_3ef --------------------- */ static double _nrrd_TMF_dn_cn_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 942 return 1.0; } static double _nrrd_TMF_dn_cn_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 947 return 2; } static double _nrrd_TMF_dn_cn_3ef_1_d( double x, const double *parm ) { int i; 953 x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_cn_3ef( parm[0], i, x ); } static float _nrrd_TMF_dn_cn_3ef_1_f( float x, const double *parm ) { int i; 964 x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_cn_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_cn_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 975 size_t I; int i; for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_cn_3ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_cn_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 990 size_t I; int i; for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_cn_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_cn_3ef = { "TMF_dn_cn_3ef", 1, _nrrd_TMF_dn_cn_3ef_Sup, _nrrd_TMF_dn_cn_3ef_Int, _nrrd_TMF_dn_cn_3ef_1_f, _nrrd_TMF_dn_cn_3ef_N_f, _nrrd_TMF_dn_cn_3ef_1_d, _nrrd_TMF_dn_cn_3ef_N_d }; /* ------------------------ TMF_dn_cn_4ef --------------------- */ static double _nrrd_TMF_dn_cn_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 1015 return 1.0; } static double _nrrd_TMF_dn_cn_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 1020 return 2; } static double _nrrd_TMF_dn_cn_4ef_1_d( double x, const double *parm ) { int i; 1026 AIR_UNUSED( parm ); /* TMF_dn_cn_4ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_cn_4ef( parm[0], i, x ); } static float _nrrd_TMF_dn_cn_4ef_1_f( float x, const double *parm ) { int i; 1037 AIR_UNUSED( parm ); /* TMF_dn_cn_4ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_cn_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_cn_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 1048 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_cn_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_cn_4ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_cn_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 1063 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_cn_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_cn_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_cn_4ef = { "TMF_dn_cn_4ef", 1, _nrrd_TMF_dn_cn_4ef_Sup, _nrrd_TMF_dn_cn_4ef_Int, _nrrd_TMF_dn_cn_4ef_1_f, _nrrd_TMF_dn_cn_4ef_N_f, _nrrd_TMF_dn_cn_4ef_1_d, _nrrd_TMF_dn_cn_4ef_N_d }; /* ------------------------ TMF_dn_c0_1ef --------------------- */ static double _nrrd_TMF_dn_c0_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 1088 return 1.0; } static double _nrrd_TMF_dn_c0_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 1093 return 1; } static double _nrrd_TMF_dn_c0_1ef_1_d( double x, const double *parm ) { int i; 1099 AIR_UNUSED( parm ); /* TMF_dn_c0_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_c0_1ef( parm[0], i, x ); } static float _nrrd_TMF_dn_c0_1ef_1_f( float x, const double *parm ) { int i; 1110 AIR_UNUSED( parm ); /* TMF_dn_c0_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_c0_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_c0_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 1121 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c0_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_c0_1ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_c0_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 1136 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c0_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_c0_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_c0_1ef = { "TMF_dn_c0_1ef", 1, _nrrd_TMF_dn_c0_1ef_Sup, _nrrd_TMF_dn_c0_1ef_Int, _nrrd_TMF_dn_c0_1ef_1_f, _nrrd_TMF_dn_c0_1ef_N_f, _nrrd_TMF_dn_c0_1ef_1_d, _nrrd_TMF_dn_c0_1ef_N_d }; /* ------------------------ TMF_dn_c0_2ef --------------------- */ static double _nrrd_TMF_dn_c0_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 1161 return 1.0; } static double _nrrd_TMF_dn_c0_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 1166 return 1; } static double _nrrd_TMF_dn_c0_2ef_1_d( double x, const double *parm ) { int i; 1172 AIR_UNUSED( parm ); /* TMF_dn_c0_2ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_c0_2ef( parm[0], i, x ); } static float _nrrd_TMF_dn_c0_2ef_1_f( float x, const double *parm ) { int i; 1183 AIR_UNUSED( parm ); /* TMF_dn_c0_2ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_c0_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_c0_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 1194 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c0_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_c0_2ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_c0_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 1209 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c0_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_c0_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_c0_2ef = { "TMF_dn_c0_2ef", 1, _nrrd_TMF_dn_c0_2ef_Sup, _nrrd_TMF_dn_c0_2ef_Int, _nrrd_TMF_dn_c0_2ef_1_f, _nrrd_TMF_dn_c0_2ef_N_f, _nrrd_TMF_dn_c0_2ef_1_d, _nrrd_TMF_dn_c0_2ef_N_d }; /* ------------------------ TMF_dn_c0_3ef --------------------- */ static double _nrrd_TMF_dn_c0_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 1234 return 1.0; } static double _nrrd_TMF_dn_c0_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 1239 return 2; } static double _nrrd_TMF_dn_c0_3ef_1_d( double x, const double *parm ) { int i; 1245 AIR_UNUSED( parm ); /* TMF_dn_c0_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_c0_3ef( parm[0], i, x ); } static float _nrrd_TMF_dn_c0_3ef_1_f( float x, const double *parm ) { int i; 1256 AIR_UNUSED( parm ); /* TMF_dn_c0_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_c0_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_c0_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 1267 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c0_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_c0_3ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_c0_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 1282 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c0_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_c0_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_c0_3ef = { "TMF_dn_c0_3ef", 1, _nrrd_TMF_dn_c0_3ef_Sup, _nrrd_TMF_dn_c0_3ef_Int, _nrrd_TMF_dn_c0_3ef_1_f, _nrrd_TMF_dn_c0_3ef_N_f, _nrrd_TMF_dn_c0_3ef_1_d, _nrrd_TMF_dn_c0_3ef_N_d }; /* ------------------------ TMF_dn_c0_4ef --------------------- */ static double _nrrd_TMF_dn_c0_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 1307 return 1.0; } static double _nrrd_TMF_dn_c0_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 1312 return 2; } static double _nrrd_TMF_dn_c0_4ef_1_d( double x, const double *parm ) { int i; 1318 AIR_UNUSED( parm ); /* TMF_dn_c0_4ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_c0_4ef( parm[0], i, x ); } static float _nrrd_TMF_dn_c0_4ef_1_f( float x, const double *parm ) { int i; 1329 AIR_UNUSED( parm ); /* TMF_dn_c0_4ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_c0_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_c0_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 1340 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c0_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_c0_4ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_c0_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 1355 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c0_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_c0_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_c0_4ef = { "TMF_dn_c0_4ef", 1, _nrrd_TMF_dn_c0_4ef_Sup, _nrrd_TMF_dn_c0_4ef_Int, _nrrd_TMF_dn_c0_4ef_1_f, _nrrd_TMF_dn_c0_4ef_N_f, _nrrd_TMF_dn_c0_4ef_1_d, _nrrd_TMF_dn_c0_4ef_N_d }; /* ------------------------ TMF_dn_c1_1ef --------------------- */ static double _nrrd_TMF_dn_c1_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 1380 return 1.0; } static double _nrrd_TMF_dn_c1_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 1385 return 1; } static double _nrrd_TMF_dn_c1_1ef_1_d( double x, const double *parm ) { int i; 1391 AIR_UNUSED( parm ); /* TMF_dn_c1_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_c1_1ef( parm[0], i, x ); } static float _nrrd_TMF_dn_c1_1ef_1_f( float x, const double *parm ) { int i; 1402 AIR_UNUSED( parm ); /* TMF_dn_c1_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_c1_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_c1_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 1413 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c1_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_c1_1ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_c1_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 1428 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c1_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_c1_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_c1_1ef = { "TMF_dn_c1_1ef", 1, _nrrd_TMF_dn_c1_1ef_Sup, _nrrd_TMF_dn_c1_1ef_Int, _nrrd_TMF_dn_c1_1ef_1_f, _nrrd_TMF_dn_c1_1ef_N_f, _nrrd_TMF_dn_c1_1ef_1_d, _nrrd_TMF_dn_c1_1ef_N_d }; /* ------------------------ TMF_dn_c1_2ef --------------------- */ static double _nrrd_TMF_dn_c1_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 1453 return 1.0; } static double _nrrd_TMF_dn_c1_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 1458 return 2; } static double _nrrd_TMF_dn_c1_2ef_1_d( double x, const double *parm ) { int i; 1464 AIR_UNUSED( parm ); /* TMF_dn_c1_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_c1_2ef( parm[0], i, x ); } static float _nrrd_TMF_dn_c1_2ef_1_f( float x, const double *parm ) { int i; 1475 AIR_UNUSED( parm ); /* TMF_dn_c1_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_c1_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_c1_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 1486 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c1_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_c1_2ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_c1_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 1501 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c1_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_c1_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_c1_2ef = { "TMF_dn_c1_2ef", 1, _nrrd_TMF_dn_c1_2ef_Sup, _nrrd_TMF_dn_c1_2ef_Int, _nrrd_TMF_dn_c1_2ef_1_f, _nrrd_TMF_dn_c1_2ef_N_f, _nrrd_TMF_dn_c1_2ef_1_d, _nrrd_TMF_dn_c1_2ef_N_d }; /* ------------------------ TMF_dn_c1_3ef --------------------- */ static double _nrrd_TMF_dn_c1_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 1526 return 1.0; } static double _nrrd_TMF_dn_c1_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 1531 return 2; } static double _nrrd_TMF_dn_c1_3ef_1_d( double x, const double *parm ) { int i; 1537 AIR_UNUSED( parm ); /* TMF_dn_c1_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_c1_3ef( parm[0], i, x ); } static float _nrrd_TMF_dn_c1_3ef_1_f( float x, const double *parm ) { int i; 1548 AIR_UNUSED( parm ); /* TMF_dn_c1_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_c1_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_c1_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 1559 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c1_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_c1_3ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_c1_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 1574 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c1_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_c1_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_c1_3ef = { "TMF_dn_c1_3ef", 1, _nrrd_TMF_dn_c1_3ef_Sup, _nrrd_TMF_dn_c1_3ef_Int, _nrrd_TMF_dn_c1_3ef_1_f, _nrrd_TMF_dn_c1_3ef_N_f, _nrrd_TMF_dn_c1_3ef_1_d, _nrrd_TMF_dn_c1_3ef_N_d }; /* ------------------------ TMF_dn_c1_4ef --------------------- */ static double _nrrd_TMF_dn_c1_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 1599 return 1.0; } static double _nrrd_TMF_dn_c1_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 1604 return 3; } static double _nrrd_TMF_dn_c1_4ef_1_d( double x, const double *parm ) { int i; 1610 x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_c1_4ef( parm[0], i, x ); } static float _nrrd_TMF_dn_c1_4ef_1_f( float x, const double *parm ) { int i; 1621 x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_c1_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_c1_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 1632 size_t I; int i; for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_c1_4ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_c1_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 1647 size_t I; int i; for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_c1_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_c1_4ef = { "TMF_dn_c1_4ef", 1, _nrrd_TMF_dn_c1_4ef_Sup, _nrrd_TMF_dn_c1_4ef_Int, _nrrd_TMF_dn_c1_4ef_1_f, _nrrd_TMF_dn_c1_4ef_N_f, _nrrd_TMF_dn_c1_4ef_1_d, _nrrd_TMF_dn_c1_4ef_N_d }; /* ------------------------ TMF_dn_c2_1ef --------------------- */ static double _nrrd_TMF_dn_c2_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 1672 return 1.0; } static double _nrrd_TMF_dn_c2_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 1677 return 1; } static double _nrrd_TMF_dn_c2_1ef_1_d( double x, const double *parm ) { int i; 1683 AIR_UNUSED( parm ); /* TMF_dn_c2_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_c2_1ef( parm[0], i, x ); } static float _nrrd_TMF_dn_c2_1ef_1_f( float x, const double *parm ) { int i; 1694 AIR_UNUSED( parm ); /* TMF_dn_c2_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_c2_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_c2_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 1705 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c2_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_c2_1ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_c2_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 1720 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c2_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_c2_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_c2_1ef = { "TMF_dn_c2_1ef", 1, _nrrd_TMF_dn_c2_1ef_Sup, _nrrd_TMF_dn_c2_1ef_Int, _nrrd_TMF_dn_c2_1ef_1_f, _nrrd_TMF_dn_c2_1ef_N_f, _nrrd_TMF_dn_c2_1ef_1_d, _nrrd_TMF_dn_c2_1ef_N_d }; /* ------------------------ TMF_dn_c2_2ef --------------------- */ static double _nrrd_TMF_dn_c2_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 1745 return 1.0; } static double _nrrd_TMF_dn_c2_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 1750 return 2; } static double _nrrd_TMF_dn_c2_2ef_1_d( double x, const double *parm ) { int i; 1756 AIR_UNUSED( parm ); /* TMF_dn_c2_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_c2_2ef( parm[0], i, x ); } static float _nrrd_TMF_dn_c2_2ef_1_f( float x, const double *parm ) { int i; 1767 AIR_UNUSED( parm ); /* TMF_dn_c2_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_c2_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_c2_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 1778 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c2_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_c2_2ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_c2_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 1793 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c2_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_c2_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_c2_2ef = { "TMF_dn_c2_2ef", 1, _nrrd_TMF_dn_c2_2ef_Sup, _nrrd_TMF_dn_c2_2ef_Int, _nrrd_TMF_dn_c2_2ef_1_f, _nrrd_TMF_dn_c2_2ef_N_f, _nrrd_TMF_dn_c2_2ef_1_d, _nrrd_TMF_dn_c2_2ef_N_d }; /* ------------------------ TMF_dn_c2_3ef --------------------- */ static double _nrrd_TMF_dn_c2_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 1818 return 1.0; } static double _nrrd_TMF_dn_c2_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 1823 return 2; } static double _nrrd_TMF_dn_c2_3ef_1_d( double x, const double *parm ) { int i; 1829 AIR_UNUSED( parm ); /* TMF_dn_c2_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_c2_3ef( parm[0], i, x ); } static float _nrrd_TMF_dn_c2_3ef_1_f( float x, const double *parm ) { int i; 1840 AIR_UNUSED( parm ); /* TMF_dn_c2_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_c2_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_c2_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 1851 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c2_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_c2_3ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_c2_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 1866 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c2_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_c2_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_c2_3ef = { "TMF_dn_c2_3ef", 1, _nrrd_TMF_dn_c2_3ef_Sup, _nrrd_TMF_dn_c2_3ef_Int, _nrrd_TMF_dn_c2_3ef_1_f, _nrrd_TMF_dn_c2_3ef_N_f, _nrrd_TMF_dn_c2_3ef_1_d, _nrrd_TMF_dn_c2_3ef_N_d }; /* ------------------------ TMF_dn_c2_4ef --------------------- */ static double _nrrd_TMF_dn_c2_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 1891 return 1.0; } static double _nrrd_TMF_dn_c2_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 1896 return 3; } static double _nrrd_TMF_dn_c2_4ef_1_d( double x, const double *parm ) { int i; 1902 AIR_UNUSED( parm ); /* TMF_dn_c2_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_c2_4ef( parm[0], i, x ); } static float _nrrd_TMF_dn_c2_4ef_1_f( float x, const double *parm ) { int i; 1913 AIR_UNUSED( parm ); /* TMF_dn_c2_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_c2_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_c2_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 1924 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c2_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_c2_4ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_c2_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 1939 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c2_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_c2_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_c2_4ef = { "TMF_dn_c2_4ef", 1, _nrrd_TMF_dn_c2_4ef_Sup, _nrrd_TMF_dn_c2_4ef_Int, _nrrd_TMF_dn_c2_4ef_1_f, _nrrd_TMF_dn_c2_4ef_N_f, _nrrd_TMF_dn_c2_4ef_1_d, _nrrd_TMF_dn_c2_4ef_N_d }; /* ------------------------ TMF_dn_c3_1ef --------------------- */ static double _nrrd_TMF_dn_c3_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 1964 return 1.0; } static double _nrrd_TMF_dn_c3_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 1969 return 1; } static double _nrrd_TMF_dn_c3_1ef_1_d( double x, const double *parm ) { int i; 1975 AIR_UNUSED( parm ); /* TMF_dn_c3_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_c3_1ef( parm[0], i, x ); } static float _nrrd_TMF_dn_c3_1ef_1_f( float x, const double *parm ) { int i; 1986 AIR_UNUSED( parm ); /* TMF_dn_c3_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_c3_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_c3_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 1997 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c3_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_c3_1ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_c3_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 2012 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c3_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_c3_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_c3_1ef = { "TMF_dn_c3_1ef", 1, _nrrd_TMF_dn_c3_1ef_Sup, _nrrd_TMF_dn_c3_1ef_Int, _nrrd_TMF_dn_c3_1ef_1_f, _nrrd_TMF_dn_c3_1ef_N_f, _nrrd_TMF_dn_c3_1ef_1_d, _nrrd_TMF_dn_c3_1ef_N_d }; /* ------------------------ TMF_dn_c3_2ef --------------------- */ static double _nrrd_TMF_dn_c3_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 2037 return 1.0; } static double _nrrd_TMF_dn_c3_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 2042 return 2; } static double _nrrd_TMF_dn_c3_2ef_1_d( double x, const double *parm ) { int i; 2048 AIR_UNUSED( parm ); /* TMF_dn_c3_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_c3_2ef( parm[0], i, x ); } static float _nrrd_TMF_dn_c3_2ef_1_f( float x, const double *parm ) { int i; 2059 AIR_UNUSED( parm ); /* TMF_dn_c3_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_c3_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_c3_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 2070 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c3_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_c3_2ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_c3_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 2085 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c3_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_c3_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_c3_2ef = { "TMF_dn_c3_2ef", 1, _nrrd_TMF_dn_c3_2ef_Sup, _nrrd_TMF_dn_c3_2ef_Int, _nrrd_TMF_dn_c3_2ef_1_f, _nrrd_TMF_dn_c3_2ef_N_f, _nrrd_TMF_dn_c3_2ef_1_d, _nrrd_TMF_dn_c3_2ef_N_d }; /* ------------------------ TMF_dn_c3_3ef --------------------- */ static double _nrrd_TMF_dn_c3_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 2110 return 1.0; } static double _nrrd_TMF_dn_c3_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 2115 return 2; } static double _nrrd_TMF_dn_c3_3ef_1_d( double x, const double *parm ) { int i; 2121 AIR_UNUSED( parm ); /* TMF_dn_c3_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_c3_3ef( parm[0], i, x ); } static float _nrrd_TMF_dn_c3_3ef_1_f( float x, const double *parm ) { int i; 2132 AIR_UNUSED( parm ); /* TMF_dn_c3_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_c3_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_c3_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 2143 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c3_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_c3_3ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_c3_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 2158 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c3_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_c3_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_c3_3ef = { "TMF_dn_c3_3ef", 1, _nrrd_TMF_dn_c3_3ef_Sup, _nrrd_TMF_dn_c3_3ef_Int, _nrrd_TMF_dn_c3_3ef_1_f, _nrrd_TMF_dn_c3_3ef_N_f, _nrrd_TMF_dn_c3_3ef_1_d, _nrrd_TMF_dn_c3_3ef_N_d }; /* ------------------------ TMF_dn_c3_4ef --------------------- */ static double _nrrd_TMF_dn_c3_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 2183 return 1.0; } static double _nrrd_TMF_dn_c3_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 2188 return 3; } static double _nrrd_TMF_dn_c3_4ef_1_d( double x, const double *parm ) { int i; 2194 AIR_UNUSED( parm ); /* TMF_dn_c3_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_dn_c3_4ef( parm[0], i, x ); } static float _nrrd_TMF_dn_c3_4ef_1_f( float x, const double *parm ) { int i; 2205 AIR_UNUSED( parm ); /* TMF_dn_c3_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_dn_c3_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_dn_c3_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 2216 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c3_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_dn_c3_4ef( parm[0], i, t ); } } static void _nrrd_TMF_dn_c3_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 2231 size_t I; int i; AIR_UNUSED( parm ); /* TMF_dn_c3_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_dn_c3_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_dn_c3_4ef = { "TMF_dn_c3_4ef", 1, _nrrd_TMF_dn_c3_4ef_Sup, _nrrd_TMF_dn_c3_4ef_Int, _nrrd_TMF_dn_c3_4ef_1_f, _nrrd_TMF_dn_c3_4ef_N_f, _nrrd_TMF_dn_c3_4ef_1_d, _nrrd_TMF_dn_c3_4ef_N_d }; /* ------------------------ TMF_d0_cn_1ef --------------------- */ static double _nrrd_TMF_d0_cn_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 2256 return 1.0; } static double _nrrd_TMF_d0_cn_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 2261 return 1; } static double _nrrd_TMF_d0_cn_1ef_1_d( double x, const double *parm ) { int i; 2267 AIR_UNUSED( parm ); /* TMF_d0_cn_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_cn_1ef( parm[0], i, x ); } static float _nrrd_TMF_d0_cn_1ef_1_f( float x, const double *parm ) { int i; 2278 AIR_UNUSED( parm ); /* TMF_d0_cn_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_cn_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_cn_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 2289 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_cn_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_cn_1ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_cn_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 2304 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_cn_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_cn_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_cn_1ef = { "TMF_d0_cn_1ef", 1, _nrrd_TMF_d0_cn_1ef_Sup, _nrrd_TMF_d0_cn_1ef_Int, _nrrd_TMF_d0_cn_1ef_1_f, _nrrd_TMF_d0_cn_1ef_N_f, _nrrd_TMF_d0_cn_1ef_1_d, _nrrd_TMF_d0_cn_1ef_N_d }; /* ------------------------ TMF_d0_cn_2ef --------------------- */ static double _nrrd_TMF_d0_cn_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 2329 return 1.0; } static double _nrrd_TMF_d0_cn_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 2334 return 1; } static double _nrrd_TMF_d0_cn_2ef_1_d( double x, const double *parm ) { int i; 2340 AIR_UNUSED( parm ); /* TMF_d0_cn_2ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_cn_2ef( parm[0], i, x ); } static float _nrrd_TMF_d0_cn_2ef_1_f( float x, const double *parm ) { int i; 2351 AIR_UNUSED( parm ); /* TMF_d0_cn_2ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_cn_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_cn_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 2362 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_cn_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_cn_2ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_cn_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 2377 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_cn_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_cn_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_cn_2ef = { "TMF_d0_cn_2ef", 1, _nrrd_TMF_d0_cn_2ef_Sup, _nrrd_TMF_d0_cn_2ef_Int, _nrrd_TMF_d0_cn_2ef_1_f, _nrrd_TMF_d0_cn_2ef_N_f, _nrrd_TMF_d0_cn_2ef_1_d, _nrrd_TMF_d0_cn_2ef_N_d }; /* ------------------------ TMF_d0_cn_3ef --------------------- */ static double _nrrd_TMF_d0_cn_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 2402 return 1.0; } static double _nrrd_TMF_d0_cn_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 2407 return 2; } static double _nrrd_TMF_d0_cn_3ef_1_d( double x, const double *parm ) { int i; 2413 AIR_UNUSED( parm ); /* TMF_d0_cn_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_cn_3ef( parm[0], i, x ); } static float _nrrd_TMF_d0_cn_3ef_1_f( float x, const double *parm ) { int i; 2424 AIR_UNUSED( parm ); /* TMF_d0_cn_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_cn_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_cn_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 2435 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_cn_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_cn_3ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_cn_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 2450 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_cn_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_cn_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_cn_3ef = { "TMF_d0_cn_3ef", 1, _nrrd_TMF_d0_cn_3ef_Sup, _nrrd_TMF_d0_cn_3ef_Int, _nrrd_TMF_d0_cn_3ef_1_f, _nrrd_TMF_d0_cn_3ef_N_f, _nrrd_TMF_d0_cn_3ef_1_d, _nrrd_TMF_d0_cn_3ef_N_d }; /* ------------------------ TMF_d0_cn_4ef --------------------- */ static double _nrrd_TMF_d0_cn_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 2475 return 1.0; } static double _nrrd_TMF_d0_cn_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 2480 return 2; } static double _nrrd_TMF_d0_cn_4ef_1_d( double x, const double *parm ) { int i; 2486 AIR_UNUSED( parm ); /* TMF_d0_cn_4ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_cn_4ef( parm[0], i, x ); } static float _nrrd_TMF_d0_cn_4ef_1_f( float x, const double *parm ) { int i; 2497 AIR_UNUSED( parm ); /* TMF_d0_cn_4ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_cn_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_cn_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 2508 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_cn_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_cn_4ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_cn_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 2523 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_cn_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_cn_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_cn_4ef = { "TMF_d0_cn_4ef", 1, _nrrd_TMF_d0_cn_4ef_Sup, _nrrd_TMF_d0_cn_4ef_Int, _nrrd_TMF_d0_cn_4ef_1_f, _nrrd_TMF_d0_cn_4ef_N_f, _nrrd_TMF_d0_cn_4ef_1_d, _nrrd_TMF_d0_cn_4ef_N_d }; /* ------------------------ TMF_d0_c0_1ef --------------------- */ static double _nrrd_TMF_d0_c0_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 2548 return 1.0; } static double _nrrd_TMF_d0_c0_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 2553 return 1; } static double _nrrd_TMF_d0_c0_1ef_1_d( double x, const double *parm ) { int i; 2559 AIR_UNUSED( parm ); /* TMF_d0_c0_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_c0_1ef( parm[0], i, x ); } static float _nrrd_TMF_d0_c0_1ef_1_f( float x, const double *parm ) { int i; 2570 AIR_UNUSED( parm ); /* TMF_d0_c0_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_c0_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_c0_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 2581 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c0_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_c0_1ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_c0_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 2596 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c0_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_c0_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_c0_1ef = { "TMF_d0_c0_1ef", 1, _nrrd_TMF_d0_c0_1ef_Sup, _nrrd_TMF_d0_c0_1ef_Int, _nrrd_TMF_d0_c0_1ef_1_f, _nrrd_TMF_d0_c0_1ef_N_f, _nrrd_TMF_d0_c0_1ef_1_d, _nrrd_TMF_d0_c0_1ef_N_d }; /* ------------------------ TMF_d0_c0_2ef --------------------- */ static double _nrrd_TMF_d0_c0_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 2621 return 1.0; } static double _nrrd_TMF_d0_c0_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 2626 return 1; } static double _nrrd_TMF_d0_c0_2ef_1_d( double x, const double *parm ) { int i; 2632 AIR_UNUSED( parm ); /* TMF_d0_c0_2ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_c0_2ef( parm[0], i, x ); } static float _nrrd_TMF_d0_c0_2ef_1_f( float x, const double *parm ) { int i; 2643 AIR_UNUSED( parm ); /* TMF_d0_c0_2ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_c0_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_c0_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 2654 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c0_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_c0_2ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_c0_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 2669 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c0_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_c0_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_c0_2ef = { "TMF_d0_c0_2ef", 1, _nrrd_TMF_d0_c0_2ef_Sup, _nrrd_TMF_d0_c0_2ef_Int, _nrrd_TMF_d0_c0_2ef_1_f, _nrrd_TMF_d0_c0_2ef_N_f, _nrrd_TMF_d0_c0_2ef_1_d, _nrrd_TMF_d0_c0_2ef_N_d }; /* ------------------------ TMF_d0_c0_3ef --------------------- */ static double _nrrd_TMF_d0_c0_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 2694 return 1.0; } static double _nrrd_TMF_d0_c0_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 2699 return 2; } static double _nrrd_TMF_d0_c0_3ef_1_d( double x, const double *parm ) { int i; 2705 AIR_UNUSED( parm ); /* TMF_d0_c0_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_c0_3ef( parm[0], i, x ); } static float _nrrd_TMF_d0_c0_3ef_1_f( float x, const double *parm ) { int i; 2716 AIR_UNUSED( parm ); /* TMF_d0_c0_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_c0_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_c0_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 2727 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c0_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_c0_3ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_c0_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 2742 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c0_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_c0_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_c0_3ef = { "TMF_d0_c0_3ef", 1, _nrrd_TMF_d0_c0_3ef_Sup, _nrrd_TMF_d0_c0_3ef_Int, _nrrd_TMF_d0_c0_3ef_1_f, _nrrd_TMF_d0_c0_3ef_N_f, _nrrd_TMF_d0_c0_3ef_1_d, _nrrd_TMF_d0_c0_3ef_N_d }; /* ------------------------ TMF_d0_c0_4ef --------------------- */ static double _nrrd_TMF_d0_c0_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 2767 return 1.0; } static double _nrrd_TMF_d0_c0_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 2772 return 2; } static double _nrrd_TMF_d0_c0_4ef_1_d( double x, const double *parm ) { int i; 2778 AIR_UNUSED( parm ); /* TMF_d0_c0_4ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_c0_4ef( parm[0], i, x ); } static float _nrrd_TMF_d0_c0_4ef_1_f( float x, const double *parm ) { int i; 2789 AIR_UNUSED( parm ); /* TMF_d0_c0_4ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_c0_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_c0_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 2800 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c0_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_c0_4ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_c0_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 2815 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c0_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_c0_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_c0_4ef = { "TMF_d0_c0_4ef", 1, _nrrd_TMF_d0_c0_4ef_Sup, _nrrd_TMF_d0_c0_4ef_Int, _nrrd_TMF_d0_c0_4ef_1_f, _nrrd_TMF_d0_c0_4ef_N_f, _nrrd_TMF_d0_c0_4ef_1_d, _nrrd_TMF_d0_c0_4ef_N_d }; /* ------------------------ TMF_d0_c1_1ef --------------------- */ static double _nrrd_TMF_d0_c1_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 2840 return 1.0; } static double _nrrd_TMF_d0_c1_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 2845 return 1; } static double _nrrd_TMF_d0_c1_1ef_1_d( double x, const double *parm ) { int i; 2851 AIR_UNUSED( parm ); /* TMF_d0_c1_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_c1_1ef( parm[0], i, x ); } static float _nrrd_TMF_d0_c1_1ef_1_f( float x, const double *parm ) { int i; 2862 AIR_UNUSED( parm ); /* TMF_d0_c1_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_c1_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_c1_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 2873 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c1_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_c1_1ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_c1_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 2888 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c1_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_c1_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_c1_1ef = { "TMF_d0_c1_1ef", 1, _nrrd_TMF_d0_c1_1ef_Sup, _nrrd_TMF_d0_c1_1ef_Int, _nrrd_TMF_d0_c1_1ef_1_f, _nrrd_TMF_d0_c1_1ef_N_f, _nrrd_TMF_d0_c1_1ef_1_d, _nrrd_TMF_d0_c1_1ef_N_d }; /* ------------------------ TMF_d0_c1_2ef --------------------- */ static double _nrrd_TMF_d0_c1_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 2913 return 1.0; } static double _nrrd_TMF_d0_c1_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 2918 return 2; } static double _nrrd_TMF_d0_c1_2ef_1_d( double x, const double *parm ) { int i; 2924 AIR_UNUSED( parm ); /* TMF_d0_c1_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_c1_2ef( parm[0], i, x ); } static float _nrrd_TMF_d0_c1_2ef_1_f( float x, const double *parm ) { int i; 2935 AIR_UNUSED( parm ); /* TMF_d0_c1_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_c1_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_c1_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 2946 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c1_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_c1_2ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_c1_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 2961 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c1_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_c1_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_c1_2ef = { "TMF_d0_c1_2ef", 1, _nrrd_TMF_d0_c1_2ef_Sup, _nrrd_TMF_d0_c1_2ef_Int, _nrrd_TMF_d0_c1_2ef_1_f, _nrrd_TMF_d0_c1_2ef_N_f, _nrrd_TMF_d0_c1_2ef_1_d, _nrrd_TMF_d0_c1_2ef_N_d }; /* ------------------------ TMF_d0_c1_3ef --------------------- */ static double _nrrd_TMF_d0_c1_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 2986 return 1.0; } static double _nrrd_TMF_d0_c1_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 2991 return 2; } static double _nrrd_TMF_d0_c1_3ef_1_d( double x, const double *parm ) { int i; 2997 AIR_UNUSED( parm ); /* TMF_d0_c1_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_c1_3ef( parm[0], i, x ); } static float _nrrd_TMF_d0_c1_3ef_1_f( float x, const double *parm ) { int i; 3008 AIR_UNUSED( parm ); /* TMF_d0_c1_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_c1_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_c1_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 3019 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c1_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_c1_3ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_c1_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 3034 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c1_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_c1_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_c1_3ef = { "TMF_d0_c1_3ef", 1, _nrrd_TMF_d0_c1_3ef_Sup, _nrrd_TMF_d0_c1_3ef_Int, _nrrd_TMF_d0_c1_3ef_1_f, _nrrd_TMF_d0_c1_3ef_N_f, _nrrd_TMF_d0_c1_3ef_1_d, _nrrd_TMF_d0_c1_3ef_N_d }; /* ------------------------ TMF_d0_c1_4ef --------------------- */ static double _nrrd_TMF_d0_c1_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 3059 return 1.0; } static double _nrrd_TMF_d0_c1_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 3064 return 3; } static double _nrrd_TMF_d0_c1_4ef_1_d( double x, const double *parm ) { int i; 3070 AIR_UNUSED( parm ); /* TMF_d0_c1_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_c1_4ef( parm[0], i, x ); } static float _nrrd_TMF_d0_c1_4ef_1_f( float x, const double *parm ) { int i; 3081 AIR_UNUSED( parm ); /* TMF_d0_c1_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_c1_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_c1_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 3092 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c1_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_c1_4ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_c1_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 3107 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c1_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_c1_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_c1_4ef = { "TMF_d0_c1_4ef", 1, _nrrd_TMF_d0_c1_4ef_Sup, _nrrd_TMF_d0_c1_4ef_Int, _nrrd_TMF_d0_c1_4ef_1_f, _nrrd_TMF_d0_c1_4ef_N_f, _nrrd_TMF_d0_c1_4ef_1_d, _nrrd_TMF_d0_c1_4ef_N_d }; /* ------------------------ TMF_d0_c2_1ef --------------------- */ static double _nrrd_TMF_d0_c2_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 3132 return 1.0; } static double _nrrd_TMF_d0_c2_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 3137 return 1; } static double _nrrd_TMF_d0_c2_1ef_1_d( double x, const double *parm ) { int i; 3143 AIR_UNUSED( parm ); /* TMF_d0_c2_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_c2_1ef( parm[0], i, x ); } static float _nrrd_TMF_d0_c2_1ef_1_f( float x, const double *parm ) { int i; 3154 AIR_UNUSED( parm ); /* TMF_d0_c2_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_c2_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_c2_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 3165 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c2_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_c2_1ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_c2_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 3180 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c2_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_c2_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_c2_1ef = { "TMF_d0_c2_1ef", 1, _nrrd_TMF_d0_c2_1ef_Sup, _nrrd_TMF_d0_c2_1ef_Int, _nrrd_TMF_d0_c2_1ef_1_f, _nrrd_TMF_d0_c2_1ef_N_f, _nrrd_TMF_d0_c2_1ef_1_d, _nrrd_TMF_d0_c2_1ef_N_d }; /* ------------------------ TMF_d0_c2_2ef --------------------- */ static double _nrrd_TMF_d0_c2_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 3205 return 1.0; } static double _nrrd_TMF_d0_c2_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 3210 return 2; } static double _nrrd_TMF_d0_c2_2ef_1_d( double x, const double *parm ) { int i; 3216 AIR_UNUSED( parm ); /* TMF_d0_c2_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_c2_2ef( parm[0], i, x ); } static float _nrrd_TMF_d0_c2_2ef_1_f( float x, const double *parm ) { int i; 3227 AIR_UNUSED( parm ); /* TMF_d0_c2_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_c2_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_c2_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 3238 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c2_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_c2_2ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_c2_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 3253 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c2_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_c2_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_c2_2ef = { "TMF_d0_c2_2ef", 1, _nrrd_TMF_d0_c2_2ef_Sup, _nrrd_TMF_d0_c2_2ef_Int, _nrrd_TMF_d0_c2_2ef_1_f, _nrrd_TMF_d0_c2_2ef_N_f, _nrrd_TMF_d0_c2_2ef_1_d, _nrrd_TMF_d0_c2_2ef_N_d }; /* ------------------------ TMF_d0_c2_3ef --------------------- */ static double _nrrd_TMF_d0_c2_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 3278 return 1.0; } static double _nrrd_TMF_d0_c2_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 3283 return 2; } static double _nrrd_TMF_d0_c2_3ef_1_d( double x, const double *parm ) { int i; 3289 AIR_UNUSED( parm ); /* TMF_d0_c2_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_c2_3ef( parm[0], i, x ); } static float _nrrd_TMF_d0_c2_3ef_1_f( float x, const double *parm ) { int i; 3300 AIR_UNUSED( parm ); /* TMF_d0_c2_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_c2_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_c2_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 3311 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c2_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_c2_3ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_c2_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 3326 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c2_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_c2_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_c2_3ef = { "TMF_d0_c2_3ef", 1, _nrrd_TMF_d0_c2_3ef_Sup, _nrrd_TMF_d0_c2_3ef_Int, _nrrd_TMF_d0_c2_3ef_1_f, _nrrd_TMF_d0_c2_3ef_N_f, _nrrd_TMF_d0_c2_3ef_1_d, _nrrd_TMF_d0_c2_3ef_N_d }; /* ------------------------ TMF_d0_c2_4ef --------------------- */ static double _nrrd_TMF_d0_c2_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 3351 return 1.0; } static double _nrrd_TMF_d0_c2_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 3356 return 3; } static double _nrrd_TMF_d0_c2_4ef_1_d( double x, const double *parm ) { int i; 3362 AIR_UNUSED( parm ); /* TMF_d0_c2_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_c2_4ef( parm[0], i, x ); } static float _nrrd_TMF_d0_c2_4ef_1_f( float x, const double *parm ) { int i; 3373 AIR_UNUSED( parm ); /* TMF_d0_c2_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_c2_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_c2_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 3384 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c2_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_c2_4ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_c2_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 3399 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c2_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_c2_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_c2_4ef = { "TMF_d0_c2_4ef", 1, _nrrd_TMF_d0_c2_4ef_Sup, _nrrd_TMF_d0_c2_4ef_Int, _nrrd_TMF_d0_c2_4ef_1_f, _nrrd_TMF_d0_c2_4ef_N_f, _nrrd_TMF_d0_c2_4ef_1_d, _nrrd_TMF_d0_c2_4ef_N_d }; /* ------------------------ TMF_d0_c3_1ef --------------------- */ static double _nrrd_TMF_d0_c3_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 3424 return 1.0; } static double _nrrd_TMF_d0_c3_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 3429 return 1; } static double _nrrd_TMF_d0_c3_1ef_1_d( double x, const double *parm ) { int i; 3435 AIR_UNUSED( parm ); /* TMF_d0_c3_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_c3_1ef( parm[0], i, x ); } static float _nrrd_TMF_d0_c3_1ef_1_f( float x, const double *parm ) { int i; 3446 AIR_UNUSED( parm ); /* TMF_d0_c3_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_c3_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_c3_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 3457 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c3_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_c3_1ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_c3_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 3472 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c3_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_c3_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_c3_1ef = { "TMF_d0_c3_1ef", 1, _nrrd_TMF_d0_c3_1ef_Sup, _nrrd_TMF_d0_c3_1ef_Int, _nrrd_TMF_d0_c3_1ef_1_f, _nrrd_TMF_d0_c3_1ef_N_f, _nrrd_TMF_d0_c3_1ef_1_d, _nrrd_TMF_d0_c3_1ef_N_d }; /* ------------------------ TMF_d0_c3_2ef --------------------- */ static double _nrrd_TMF_d0_c3_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 3497 return 1.0; } static double _nrrd_TMF_d0_c3_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 3502 return 2; } static double _nrrd_TMF_d0_c3_2ef_1_d( double x, const double *parm ) { int i; 3508 AIR_UNUSED( parm ); /* TMF_d0_c3_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_c3_2ef( parm[0], i, x ); } static float _nrrd_TMF_d0_c3_2ef_1_f( float x, const double *parm ) { int i; 3519 AIR_UNUSED( parm ); /* TMF_d0_c3_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_c3_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_c3_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 3530 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c3_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_c3_2ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_c3_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 3545 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c3_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_c3_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_c3_2ef = { "TMF_d0_c3_2ef", 1, _nrrd_TMF_d0_c3_2ef_Sup, _nrrd_TMF_d0_c3_2ef_Int, _nrrd_TMF_d0_c3_2ef_1_f, _nrrd_TMF_d0_c3_2ef_N_f, _nrrd_TMF_d0_c3_2ef_1_d, _nrrd_TMF_d0_c3_2ef_N_d }; /* ------------------------ TMF_d0_c3_3ef --------------------- */ static double _nrrd_TMF_d0_c3_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 3570 return 1.0; } static double _nrrd_TMF_d0_c3_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 3575 return 2; } static double _nrrd_TMF_d0_c3_3ef_1_d( double x, const double *parm ) { int i; 3581 AIR_UNUSED( parm ); /* TMF_d0_c3_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_c3_3ef( parm[0], i, x ); } static float _nrrd_TMF_d0_c3_3ef_1_f( float x, const double *parm ) { int i; 3592 AIR_UNUSED( parm ); /* TMF_d0_c3_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_c3_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_c3_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 3603 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c3_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_c3_3ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_c3_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 3618 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c3_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_c3_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_c3_3ef = { "TMF_d0_c3_3ef", 1, _nrrd_TMF_d0_c3_3ef_Sup, _nrrd_TMF_d0_c3_3ef_Int, _nrrd_TMF_d0_c3_3ef_1_f, _nrrd_TMF_d0_c3_3ef_N_f, _nrrd_TMF_d0_c3_3ef_1_d, _nrrd_TMF_d0_c3_3ef_N_d }; /* ------------------------ TMF_d0_c3_4ef --------------------- */ static double _nrrd_TMF_d0_c3_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 3643 return 1.0; } static double _nrrd_TMF_d0_c3_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 3648 return 3; } static double _nrrd_TMF_d0_c3_4ef_1_d( double x, const double *parm ) { int i; 3654 AIR_UNUSED( parm ); /* TMF_d0_c3_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d0_c3_4ef( parm[0], i, x ); } static float _nrrd_TMF_d0_c3_4ef_1_f( float x, const double *parm ) { int i; 3665 AIR_UNUSED( parm ); /* TMF_d0_c3_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d0_c3_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_d0_c3_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 3676 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c3_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d0_c3_4ef( parm[0], i, t ); } } static void _nrrd_TMF_d0_c3_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 3691 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d0_c3_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d0_c3_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d0_c3_4ef = { "TMF_d0_c3_4ef", 1, _nrrd_TMF_d0_c3_4ef_Sup, _nrrd_TMF_d0_c3_4ef_Int, _nrrd_TMF_d0_c3_4ef_1_f, _nrrd_TMF_d0_c3_4ef_N_f, _nrrd_TMF_d0_c3_4ef_1_d, _nrrd_TMF_d0_c3_4ef_N_d }; /* ------------------------ TMF_d1_cn_1ef --------------------- */ static double _nrrd_TMF_d1_cn_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 3716 return 0.0; } static double _nrrd_TMF_d1_cn_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 3721 return 1; } static double _nrrd_TMF_d1_cn_1ef_1_d( double x, const double *parm ) { int i; 3727 AIR_UNUSED( parm ); /* TMF_d1_cn_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_cn_1ef( parm[0], i, x ); } static float _nrrd_TMF_d1_cn_1ef_1_f( float x, const double *parm ) { int i; 3738 AIR_UNUSED( parm ); /* TMF_d1_cn_1ef */ x += 1; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_cn_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_cn_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 3749 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_cn_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_cn_1ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_cn_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 3764 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_cn_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 1; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_cn_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_cn_1ef = { "TMF_d1_cn_1ef", 1, _nrrd_TMF_d1_cn_1ef_Sup, _nrrd_TMF_d1_cn_1ef_Int, _nrrd_TMF_d1_cn_1ef_1_f, _nrrd_TMF_d1_cn_1ef_N_f, _nrrd_TMF_d1_cn_1ef_1_d, _nrrd_TMF_d1_cn_1ef_N_d }; /* ------------------------ TMF_d1_cn_2ef --------------------- */ static double _nrrd_TMF_d1_cn_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 3789 return 0.0; } static double _nrrd_TMF_d1_cn_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 3794 return 2; } static double _nrrd_TMF_d1_cn_2ef_1_d( double x, const double *parm ) { int i; 3800 x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_cn_2ef( parm[0], i, x ); } static float _nrrd_TMF_d1_cn_2ef_1_f( float x, const double *parm ) { int i; 3811 x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_cn_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_cn_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 3822 size_t I; int i; for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_cn_2ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_cn_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 3837 size_t I; int i; for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_cn_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_cn_2ef = { "TMF_d1_cn_2ef", 1, _nrrd_TMF_d1_cn_2ef_Sup, _nrrd_TMF_d1_cn_2ef_Int, _nrrd_TMF_d1_cn_2ef_1_f, _nrrd_TMF_d1_cn_2ef_N_f, _nrrd_TMF_d1_cn_2ef_1_d, _nrrd_TMF_d1_cn_2ef_N_d }; /* ------------------------ TMF_d1_cn_3ef --------------------- */ static double _nrrd_TMF_d1_cn_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 3862 return 0.0; } static double _nrrd_TMF_d1_cn_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 3867 return 2; } static double _nrrd_TMF_d1_cn_3ef_1_d( double x, const double *parm ) { int i; 3873 AIR_UNUSED( parm ); /* TMF_d1_cn_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_cn_3ef( parm[0], i, x ); } static float _nrrd_TMF_d1_cn_3ef_1_f( float x, const double *parm ) { int i; 3884 AIR_UNUSED( parm ); /* TMF_d1_cn_3ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_cn_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_cn_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 3895 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_cn_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_cn_3ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_cn_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 3910 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_cn_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_cn_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_cn_3ef = { "TMF_d1_cn_3ef", 1, _nrrd_TMF_d1_cn_3ef_Sup, _nrrd_TMF_d1_cn_3ef_Int, _nrrd_TMF_d1_cn_3ef_1_f, _nrrd_TMF_d1_cn_3ef_N_f, _nrrd_TMF_d1_cn_3ef_1_d, _nrrd_TMF_d1_cn_3ef_N_d }; /* ------------------------ TMF_d1_cn_4ef --------------------- */ static double _nrrd_TMF_d1_cn_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 3935 return 0.0; } static double _nrrd_TMF_d1_cn_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 3940 return 3; } static double _nrrd_TMF_d1_cn_4ef_1_d( double x, const double *parm ) { int i; 3946 x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_cn_4ef( parm[0], i, x ); } static float _nrrd_TMF_d1_cn_4ef_1_f( float x, const double *parm ) { int i; 3957 x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_cn_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_cn_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 3968 size_t I; int i; for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_cn_4ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_cn_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 3983 size_t I; int i; for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_cn_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_cn_4ef = { "TMF_d1_cn_4ef", 1, _nrrd_TMF_d1_cn_4ef_Sup, _nrrd_TMF_d1_cn_4ef_Int, _nrrd_TMF_d1_cn_4ef_1_f, _nrrd_TMF_d1_cn_4ef_N_f, _nrrd_TMF_d1_cn_4ef_1_d, _nrrd_TMF_d1_cn_4ef_N_d }; /* ------------------------ TMF_d1_c0_1ef --------------------- */ static double _nrrd_TMF_d1_c0_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 4008 return 0.0; } static double _nrrd_TMF_d1_c0_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 4013 return 2; } static double _nrrd_TMF_d1_c0_1ef_1_d( double x, const double *parm ) { int i; 4019 AIR_UNUSED( parm ); /* TMF_d1_c0_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_c0_1ef( parm[0], i, x ); } static float _nrrd_TMF_d1_c0_1ef_1_f( float x, const double *parm ) { int i; 4030 AIR_UNUSED( parm ); /* TMF_d1_c0_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_c0_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_c0_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 4041 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c0_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_c0_1ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_c0_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 4056 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c0_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_c0_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_c0_1ef = { "TMF_d1_c0_1ef", 1, _nrrd_TMF_d1_c0_1ef_Sup, _nrrd_TMF_d1_c0_1ef_Int, _nrrd_TMF_d1_c0_1ef_1_f, _nrrd_TMF_d1_c0_1ef_N_f, _nrrd_TMF_d1_c0_1ef_1_d, _nrrd_TMF_d1_c0_1ef_N_d }; /* ------------------------ TMF_d1_c0_2ef --------------------- */ static double _nrrd_TMF_d1_c0_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 4081 return 0.0; } static double _nrrd_TMF_d1_c0_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 4086 return 2; } static double _nrrd_TMF_d1_c0_2ef_1_d( double x, const double *parm ) { int i; 4092 AIR_UNUSED( parm ); /* TMF_d1_c0_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_c0_2ef( parm[0], i, x ); } static float _nrrd_TMF_d1_c0_2ef_1_f( float x, const double *parm ) { int i; 4103 AIR_UNUSED( parm ); /* TMF_d1_c0_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_c0_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_c0_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 4114 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c0_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_c0_2ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_c0_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 4129 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c0_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_c0_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_c0_2ef = { "TMF_d1_c0_2ef", 1, _nrrd_TMF_d1_c0_2ef_Sup, _nrrd_TMF_d1_c0_2ef_Int, _nrrd_TMF_d1_c0_2ef_1_f, _nrrd_TMF_d1_c0_2ef_N_f, _nrrd_TMF_d1_c0_2ef_1_d, _nrrd_TMF_d1_c0_2ef_N_d }; /* ------------------------ TMF_d1_c0_3ef --------------------- */ static double _nrrd_TMF_d1_c0_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 4154 return 0.0; } static double _nrrd_TMF_d1_c0_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 4159 return 3; } static double _nrrd_TMF_d1_c0_3ef_1_d( double x, const double *parm ) { int i; 4165 x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_c0_3ef( parm[0], i, x ); } static float _nrrd_TMF_d1_c0_3ef_1_f( float x, const double *parm ) { int i; 4176 x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_c0_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_c0_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 4187 size_t I; int i; for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_c0_3ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_c0_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 4202 size_t I; int i; for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_c0_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_c0_3ef = { "TMF_d1_c0_3ef", 1, _nrrd_TMF_d1_c0_3ef_Sup, _nrrd_TMF_d1_c0_3ef_Int, _nrrd_TMF_d1_c0_3ef_1_f, _nrrd_TMF_d1_c0_3ef_N_f, _nrrd_TMF_d1_c0_3ef_1_d, _nrrd_TMF_d1_c0_3ef_N_d }; /* ------------------------ TMF_d1_c0_4ef --------------------- */ static double _nrrd_TMF_d1_c0_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 4227 return 0.0; } static double _nrrd_TMF_d1_c0_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 4232 return 3; } static double _nrrd_TMF_d1_c0_4ef_1_d( double x, const double *parm ) { int i; 4238 x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_c0_4ef( parm[0], i, x ); } static float _nrrd_TMF_d1_c0_4ef_1_f( float x, const double *parm ) { int i; 4249 x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_c0_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_c0_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 4260 size_t I; int i; for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_c0_4ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_c0_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 4275 size_t I; int i; for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_c0_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_c0_4ef = { "TMF_d1_c0_4ef", 1, _nrrd_TMF_d1_c0_4ef_Sup, _nrrd_TMF_d1_c0_4ef_Int, _nrrd_TMF_d1_c0_4ef_1_f, _nrrd_TMF_d1_c0_4ef_N_f, _nrrd_TMF_d1_c0_4ef_1_d, _nrrd_TMF_d1_c0_4ef_N_d }; /* ------------------------ TMF_d1_c1_1ef --------------------- */ static double _nrrd_TMF_d1_c1_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 4300 return 0.0; } static double _nrrd_TMF_d1_c1_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 4305 return 2; } static double _nrrd_TMF_d1_c1_1ef_1_d( double x, const double *parm ) { int i; 4311 AIR_UNUSED( parm ); /* TMF_d1_c1_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_c1_1ef( parm[0], i, x ); } static float _nrrd_TMF_d1_c1_1ef_1_f( float x, const double *parm ) { int i; 4322 AIR_UNUSED( parm ); /* TMF_d1_c1_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_c1_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_c1_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 4333 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c1_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_c1_1ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_c1_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 4348 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c1_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_c1_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_c1_1ef = { "TMF_d1_c1_1ef", 1, _nrrd_TMF_d1_c1_1ef_Sup, _nrrd_TMF_d1_c1_1ef_Int, _nrrd_TMF_d1_c1_1ef_1_f, _nrrd_TMF_d1_c1_1ef_N_f, _nrrd_TMF_d1_c1_1ef_1_d, _nrrd_TMF_d1_c1_1ef_N_d }; /* ------------------------ TMF_d1_c1_2ef --------------------- */ static double _nrrd_TMF_d1_c1_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 4373 return 0.0; } static double _nrrd_TMF_d1_c1_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 4378 return 2; } static double _nrrd_TMF_d1_c1_2ef_1_d( double x, const double *parm ) { int i; 4384 AIR_UNUSED( parm ); /* TMF_d1_c1_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_c1_2ef( parm[0], i, x ); } static float _nrrd_TMF_d1_c1_2ef_1_f( float x, const double *parm ) { int i; 4395 AIR_UNUSED( parm ); /* TMF_d1_c1_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_c1_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_c1_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 4406 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c1_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_c1_2ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_c1_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 4421 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c1_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_c1_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_c1_2ef = { "TMF_d1_c1_2ef", 1, _nrrd_TMF_d1_c1_2ef_Sup, _nrrd_TMF_d1_c1_2ef_Int, _nrrd_TMF_d1_c1_2ef_1_f, _nrrd_TMF_d1_c1_2ef_N_f, _nrrd_TMF_d1_c1_2ef_1_d, _nrrd_TMF_d1_c1_2ef_N_d }; /* ------------------------ TMF_d1_c1_3ef --------------------- */ static double _nrrd_TMF_d1_c1_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 4446 return 0.0; } static double _nrrd_TMF_d1_c1_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 4451 return 3; } static double _nrrd_TMF_d1_c1_3ef_1_d( double x, const double *parm ) { int i; 4457 AIR_UNUSED( parm ); /* TMF_d1_c1_3ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_c1_3ef( parm[0], i, x ); } static float _nrrd_TMF_d1_c1_3ef_1_f( float x, const double *parm ) { int i; 4468 AIR_UNUSED( parm ); /* TMF_d1_c1_3ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_c1_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_c1_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 4479 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c1_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_c1_3ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_c1_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 4494 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c1_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_c1_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_c1_3ef = { "TMF_d1_c1_3ef", 1, _nrrd_TMF_d1_c1_3ef_Sup, _nrrd_TMF_d1_c1_3ef_Int, _nrrd_TMF_d1_c1_3ef_1_f, _nrrd_TMF_d1_c1_3ef_N_f, _nrrd_TMF_d1_c1_3ef_1_d, _nrrd_TMF_d1_c1_3ef_N_d }; /* ------------------------ TMF_d1_c1_4ef --------------------- */ static double _nrrd_TMF_d1_c1_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 4519 return 0.0; } static double _nrrd_TMF_d1_c1_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 4524 return 3; } static double _nrrd_TMF_d1_c1_4ef_1_d( double x, const double *parm ) { int i; 4530 AIR_UNUSED( parm ); /* TMF_d1_c1_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_c1_4ef( parm[0], i, x ); } static float _nrrd_TMF_d1_c1_4ef_1_f( float x, const double *parm ) { int i; 4541 AIR_UNUSED( parm ); /* TMF_d1_c1_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_c1_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_c1_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 4552 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c1_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_c1_4ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_c1_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 4567 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c1_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_c1_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_c1_4ef = { "TMF_d1_c1_4ef", 1, _nrrd_TMF_d1_c1_4ef_Sup, _nrrd_TMF_d1_c1_4ef_Int, _nrrd_TMF_d1_c1_4ef_1_f, _nrrd_TMF_d1_c1_4ef_N_f, _nrrd_TMF_d1_c1_4ef_1_d, _nrrd_TMF_d1_c1_4ef_N_d }; /* ------------------------ TMF_d1_c2_1ef --------------------- */ static double _nrrd_TMF_d1_c2_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 4592 return 0.0; } static double _nrrd_TMF_d1_c2_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 4597 return 2; } static double _nrrd_TMF_d1_c2_1ef_1_d( double x, const double *parm ) { int i; 4603 AIR_UNUSED( parm ); /* TMF_d1_c2_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_c2_1ef( parm[0], i, x ); } static float _nrrd_TMF_d1_c2_1ef_1_f( float x, const double *parm ) { int i; 4614 AIR_UNUSED( parm ); /* TMF_d1_c2_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_c2_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_c2_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 4625 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c2_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_c2_1ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_c2_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 4640 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c2_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_c2_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_c2_1ef = { "TMF_d1_c2_1ef", 1, _nrrd_TMF_d1_c2_1ef_Sup, _nrrd_TMF_d1_c2_1ef_Int, _nrrd_TMF_d1_c2_1ef_1_f, _nrrd_TMF_d1_c2_1ef_N_f, _nrrd_TMF_d1_c2_1ef_1_d, _nrrd_TMF_d1_c2_1ef_N_d }; /* ------------------------ TMF_d1_c2_2ef --------------------- */ static double _nrrd_TMF_d1_c2_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 4665 return 0.0; } static double _nrrd_TMF_d1_c2_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 4670 return 2; } static double _nrrd_TMF_d1_c2_2ef_1_d( double x, const double *parm ) { int i; 4676 AIR_UNUSED( parm ); /* TMF_d1_c2_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_c2_2ef( parm[0], i, x ); } static float _nrrd_TMF_d1_c2_2ef_1_f( float x, const double *parm ) { int i; 4687 AIR_UNUSED( parm ); /* TMF_d1_c2_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_c2_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_c2_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 4698 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c2_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_c2_2ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_c2_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 4713 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c2_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_c2_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_c2_2ef = { "TMF_d1_c2_2ef", 1, _nrrd_TMF_d1_c2_2ef_Sup, _nrrd_TMF_d1_c2_2ef_Int, _nrrd_TMF_d1_c2_2ef_1_f, _nrrd_TMF_d1_c2_2ef_N_f, _nrrd_TMF_d1_c2_2ef_1_d, _nrrd_TMF_d1_c2_2ef_N_d }; /* ------------------------ TMF_d1_c2_3ef --------------------- */ static double _nrrd_TMF_d1_c2_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 4738 return 0.0; } static double _nrrd_TMF_d1_c2_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 4743 return 3; } static double _nrrd_TMF_d1_c2_3ef_1_d( double x, const double *parm ) { int i; 4749 AIR_UNUSED( parm ); /* TMF_d1_c2_3ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_c2_3ef( parm[0], i, x ); } static float _nrrd_TMF_d1_c2_3ef_1_f( float x, const double *parm ) { int i; 4760 AIR_UNUSED( parm ); /* TMF_d1_c2_3ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_c2_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_c2_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 4771 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c2_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_c2_3ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_c2_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 4786 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c2_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_c2_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_c2_3ef = { "TMF_d1_c2_3ef", 1, _nrrd_TMF_d1_c2_3ef_Sup, _nrrd_TMF_d1_c2_3ef_Int, _nrrd_TMF_d1_c2_3ef_1_f, _nrrd_TMF_d1_c2_3ef_N_f, _nrrd_TMF_d1_c2_3ef_1_d, _nrrd_TMF_d1_c2_3ef_N_d }; /* ------------------------ TMF_d1_c2_4ef --------------------- */ static double _nrrd_TMF_d1_c2_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 4811 return 0.0; } static double _nrrd_TMF_d1_c2_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 4816 return 3; } static double _nrrd_TMF_d1_c2_4ef_1_d( double x, const double *parm ) { int i; 4822 AIR_UNUSED( parm ); /* TMF_d1_c2_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_c2_4ef( parm[0], i, x ); } static float _nrrd_TMF_d1_c2_4ef_1_f( float x, const double *parm ) { int i; 4833 AIR_UNUSED( parm ); /* TMF_d1_c2_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_c2_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_c2_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 4844 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c2_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_c2_4ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_c2_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 4859 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c2_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_c2_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_c2_4ef = { "TMF_d1_c2_4ef", 1, _nrrd_TMF_d1_c2_4ef_Sup, _nrrd_TMF_d1_c2_4ef_Int, _nrrd_TMF_d1_c2_4ef_1_f, _nrrd_TMF_d1_c2_4ef_N_f, _nrrd_TMF_d1_c2_4ef_1_d, _nrrd_TMF_d1_c2_4ef_N_d }; /* ------------------------ TMF_d1_c3_1ef --------------------- */ static double _nrrd_TMF_d1_c3_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 4884 return 0.0; } static double _nrrd_TMF_d1_c3_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 4889 return 2; } static double _nrrd_TMF_d1_c3_1ef_1_d( double x, const double *parm ) { int i; 4895 AIR_UNUSED( parm ); /* TMF_d1_c3_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_c3_1ef( parm[0], i, x ); } static float _nrrd_TMF_d1_c3_1ef_1_f( float x, const double *parm ) { int i; 4906 AIR_UNUSED( parm ); /* TMF_d1_c3_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_c3_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_c3_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 4917 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c3_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_c3_1ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_c3_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 4932 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c3_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_c3_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_c3_1ef = { "TMF_d1_c3_1ef", 1, _nrrd_TMF_d1_c3_1ef_Sup, _nrrd_TMF_d1_c3_1ef_Int, _nrrd_TMF_d1_c3_1ef_1_f, _nrrd_TMF_d1_c3_1ef_N_f, _nrrd_TMF_d1_c3_1ef_1_d, _nrrd_TMF_d1_c3_1ef_N_d }; /* ------------------------ TMF_d1_c3_2ef --------------------- */ static double _nrrd_TMF_d1_c3_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 4957 return 0.0; } static double _nrrd_TMF_d1_c3_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 4962 return 2; } static double _nrrd_TMF_d1_c3_2ef_1_d( double x, const double *parm ) { int i; 4968 AIR_UNUSED( parm ); /* TMF_d1_c3_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_c3_2ef( parm[0], i, x ); } static float _nrrd_TMF_d1_c3_2ef_1_f( float x, const double *parm ) { int i; 4979 AIR_UNUSED( parm ); /* TMF_d1_c3_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_c3_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_c3_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 4990 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c3_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_c3_2ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_c3_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 5005 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c3_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_c3_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_c3_2ef = { "TMF_d1_c3_2ef", 1, _nrrd_TMF_d1_c3_2ef_Sup, _nrrd_TMF_d1_c3_2ef_Int, _nrrd_TMF_d1_c3_2ef_1_f, _nrrd_TMF_d1_c3_2ef_N_f, _nrrd_TMF_d1_c3_2ef_1_d, _nrrd_TMF_d1_c3_2ef_N_d }; /* ------------------------ TMF_d1_c3_3ef --------------------- */ static double _nrrd_TMF_d1_c3_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 5030 return 0.0; } static double _nrrd_TMF_d1_c3_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 5035 return 3; } static double _nrrd_TMF_d1_c3_3ef_1_d( double x, const double *parm ) { int i; 5041 AIR_UNUSED( parm ); /* TMF_d1_c3_3ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_c3_3ef( parm[0], i, x ); } static float _nrrd_TMF_d1_c3_3ef_1_f( float x, const double *parm ) { int i; 5052 AIR_UNUSED( parm ); /* TMF_d1_c3_3ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_c3_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_c3_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 5063 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c3_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_c3_3ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_c3_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 5078 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c3_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_c3_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_c3_3ef = { "TMF_d1_c3_3ef", 1, _nrrd_TMF_d1_c3_3ef_Sup, _nrrd_TMF_d1_c3_3ef_Int, _nrrd_TMF_d1_c3_3ef_1_f, _nrrd_TMF_d1_c3_3ef_N_f, _nrrd_TMF_d1_c3_3ef_1_d, _nrrd_TMF_d1_c3_3ef_N_d }; /* ------------------------ TMF_d1_c3_4ef --------------------- */ static double _nrrd_TMF_d1_c3_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 5103 return 0.0; } static double _nrrd_TMF_d1_c3_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 5108 return 3; } static double _nrrd_TMF_d1_c3_4ef_1_d( double x, const double *parm ) { int i; 5114 AIR_UNUSED( parm ); /* TMF_d1_c3_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d1_c3_4ef( parm[0], i, x ); } static float _nrrd_TMF_d1_c3_4ef_1_f( float x, const double *parm ) { int i; 5125 AIR_UNUSED( parm ); /* TMF_d1_c3_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d1_c3_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_d1_c3_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 5136 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c3_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d1_c3_4ef( parm[0], i, t ); } } static void _nrrd_TMF_d1_c3_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 5151 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d1_c3_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d1_c3_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d1_c3_4ef = { "TMF_d1_c3_4ef", 1, _nrrd_TMF_d1_c3_4ef_Sup, _nrrd_TMF_d1_c3_4ef_Int, _nrrd_TMF_d1_c3_4ef_1_f, _nrrd_TMF_d1_c3_4ef_N_f, _nrrd_TMF_d1_c3_4ef_1_d, _nrrd_TMF_d1_c3_4ef_N_d }; /* ------------------------ TMF_d2_cn_1ef --------------------- */ static double _nrrd_TMF_d2_cn_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 5176 return 0.0; } static double _nrrd_TMF_d2_cn_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 5181 return 2; } static double _nrrd_TMF_d2_cn_1ef_1_d( double x, const double *parm ) { int i; 5187 AIR_UNUSED( parm ); /* TMF_d2_cn_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_cn_1ef( parm[0], i, x ); } static float _nrrd_TMF_d2_cn_1ef_1_f( float x, const double *parm ) { int i; 5198 AIR_UNUSED( parm ); /* TMF_d2_cn_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_cn_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_cn_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 5209 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_cn_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_cn_1ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_cn_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 5224 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_cn_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_cn_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_cn_1ef = { "TMF_d2_cn_1ef", 1, _nrrd_TMF_d2_cn_1ef_Sup, _nrrd_TMF_d2_cn_1ef_Int, _nrrd_TMF_d2_cn_1ef_1_f, _nrrd_TMF_d2_cn_1ef_N_f, _nrrd_TMF_d2_cn_1ef_1_d, _nrrd_TMF_d2_cn_1ef_N_d }; /* ------------------------ TMF_d2_cn_2ef --------------------- */ static double _nrrd_TMF_d2_cn_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 5249 return 0.0; } static double _nrrd_TMF_d2_cn_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 5254 return 2; } static double _nrrd_TMF_d2_cn_2ef_1_d( double x, const double *parm ) { int i; 5260 AIR_UNUSED( parm ); /* TMF_d2_cn_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_cn_2ef( parm[0], i, x ); } static float _nrrd_TMF_d2_cn_2ef_1_f( float x, const double *parm ) { int i; 5271 AIR_UNUSED( parm ); /* TMF_d2_cn_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_cn_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_cn_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 5282 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_cn_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_cn_2ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_cn_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 5297 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_cn_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_cn_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_cn_2ef = { "TMF_d2_cn_2ef", 1, _nrrd_TMF_d2_cn_2ef_Sup, _nrrd_TMF_d2_cn_2ef_Int, _nrrd_TMF_d2_cn_2ef_1_f, _nrrd_TMF_d2_cn_2ef_N_f, _nrrd_TMF_d2_cn_2ef_1_d, _nrrd_TMF_d2_cn_2ef_N_d }; /* ------------------------ TMF_d2_cn_3ef --------------------- */ static double _nrrd_TMF_d2_cn_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 5322 return 0.0; } static double _nrrd_TMF_d2_cn_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 5327 return 3; } static double _nrrd_TMF_d2_cn_3ef_1_d( double x, const double *parm ) { int i; 5333 x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_cn_3ef( parm[0], i, x ); } static float _nrrd_TMF_d2_cn_3ef_1_f( float x, const double *parm ) { int i; 5344 x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_cn_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_cn_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 5355 size_t I; int i; for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_cn_3ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_cn_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 5370 size_t I; int i; for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_cn_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_cn_3ef = { "TMF_d2_cn_3ef", 1, _nrrd_TMF_d2_cn_3ef_Sup, _nrrd_TMF_d2_cn_3ef_Int, _nrrd_TMF_d2_cn_3ef_1_f, _nrrd_TMF_d2_cn_3ef_N_f, _nrrd_TMF_d2_cn_3ef_1_d, _nrrd_TMF_d2_cn_3ef_N_d }; /* ------------------------ TMF_d2_cn_4ef --------------------- */ static double _nrrd_TMF_d2_cn_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 5395 return 0.0; } static double _nrrd_TMF_d2_cn_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 5400 return 3; } static double _nrrd_TMF_d2_cn_4ef_1_d( double x, const double *parm ) { int i; 5406 AIR_UNUSED( parm ); /* TMF_d2_cn_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_cn_4ef( parm[0], i, x ); } static float _nrrd_TMF_d2_cn_4ef_1_f( float x, const double *parm ) { int i; 5417 AIR_UNUSED( parm ); /* TMF_d2_cn_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_cn_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_cn_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 5428 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_cn_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_cn_4ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_cn_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 5443 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_cn_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_cn_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_cn_4ef = { "TMF_d2_cn_4ef", 1, _nrrd_TMF_d2_cn_4ef_Sup, _nrrd_TMF_d2_cn_4ef_Int, _nrrd_TMF_d2_cn_4ef_1_f, _nrrd_TMF_d2_cn_4ef_N_f, _nrrd_TMF_d2_cn_4ef_1_d, _nrrd_TMF_d2_cn_4ef_N_d }; /* ------------------------ TMF_d2_c0_1ef --------------------- */ static double _nrrd_TMF_d2_c0_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 5468 return 0.0; } static double _nrrd_TMF_d2_c0_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 5473 return 2; } static double _nrrd_TMF_d2_c0_1ef_1_d( double x, const double *parm ) { int i; 5479 AIR_UNUSED( parm ); /* TMF_d2_c0_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_c0_1ef( parm[0], i, x ); } static float _nrrd_TMF_d2_c0_1ef_1_f( float x, const double *parm ) { int i; 5490 AIR_UNUSED( parm ); /* TMF_d2_c0_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_c0_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_c0_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 5501 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c0_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_c0_1ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_c0_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 5516 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c0_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_c0_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_c0_1ef = { "TMF_d2_c0_1ef", 1, _nrrd_TMF_d2_c0_1ef_Sup, _nrrd_TMF_d2_c0_1ef_Int, _nrrd_TMF_d2_c0_1ef_1_f, _nrrd_TMF_d2_c0_1ef_N_f, _nrrd_TMF_d2_c0_1ef_1_d, _nrrd_TMF_d2_c0_1ef_N_d }; /* ------------------------ TMF_d2_c0_2ef --------------------- */ static double _nrrd_TMF_d2_c0_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 5541 return 0.0; } static double _nrrd_TMF_d2_c0_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 5546 return 2; } static double _nrrd_TMF_d2_c0_2ef_1_d( double x, const double *parm ) { int i; 5552 AIR_UNUSED( parm ); /* TMF_d2_c0_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_c0_2ef( parm[0], i, x ); } static float _nrrd_TMF_d2_c0_2ef_1_f( float x, const double *parm ) { int i; 5563 AIR_UNUSED( parm ); /* TMF_d2_c0_2ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_c0_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_c0_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 5574 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c0_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_c0_2ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_c0_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 5589 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c0_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_c0_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_c0_2ef = { "TMF_d2_c0_2ef", 1, _nrrd_TMF_d2_c0_2ef_Sup, _nrrd_TMF_d2_c0_2ef_Int, _nrrd_TMF_d2_c0_2ef_1_f, _nrrd_TMF_d2_c0_2ef_N_f, _nrrd_TMF_d2_c0_2ef_1_d, _nrrd_TMF_d2_c0_2ef_N_d }; /* ------------------------ TMF_d2_c0_3ef --------------------- */ static double _nrrd_TMF_d2_c0_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 5614 return 0.0; } static double _nrrd_TMF_d2_c0_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 5619 return 3; } static double _nrrd_TMF_d2_c0_3ef_1_d( double x, const double *parm ) { int i; 5625 AIR_UNUSED( parm ); /* TMF_d2_c0_3ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_c0_3ef( parm[0], i, x ); } static float _nrrd_TMF_d2_c0_3ef_1_f( float x, const double *parm ) { int i; 5636 AIR_UNUSED( parm ); /* TMF_d2_c0_3ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_c0_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_c0_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 5647 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c0_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_c0_3ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_c0_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 5662 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c0_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_c0_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_c0_3ef = { "TMF_d2_c0_3ef", 1, _nrrd_TMF_d2_c0_3ef_Sup, _nrrd_TMF_d2_c0_3ef_Int, _nrrd_TMF_d2_c0_3ef_1_f, _nrrd_TMF_d2_c0_3ef_N_f, _nrrd_TMF_d2_c0_3ef_1_d, _nrrd_TMF_d2_c0_3ef_N_d }; /* ------------------------ TMF_d2_c0_4ef --------------------- */ static double _nrrd_TMF_d2_c0_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 5687 return 0.0; } static double _nrrd_TMF_d2_c0_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 5692 return 3; } static double _nrrd_TMF_d2_c0_4ef_1_d( double x, const double *parm ) { int i; 5698 AIR_UNUSED( parm ); /* TMF_d2_c0_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_c0_4ef( parm[0], i, x ); } static float _nrrd_TMF_d2_c0_4ef_1_f( float x, const double *parm ) { int i; 5709 AIR_UNUSED( parm ); /* TMF_d2_c0_4ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_c0_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_c0_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 5720 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c0_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_c0_4ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_c0_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 5735 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c0_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_c0_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_c0_4ef = { "TMF_d2_c0_4ef", 1, _nrrd_TMF_d2_c0_4ef_Sup, _nrrd_TMF_d2_c0_4ef_Int, _nrrd_TMF_d2_c0_4ef_1_f, _nrrd_TMF_d2_c0_4ef_N_f, _nrrd_TMF_d2_c0_4ef_1_d, _nrrd_TMF_d2_c0_4ef_N_d }; /* ------------------------ TMF_d2_c1_1ef --------------------- */ static double _nrrd_TMF_d2_c1_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 5760 return 0.0; } static double _nrrd_TMF_d2_c1_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 5765 return 2; } static double _nrrd_TMF_d2_c1_1ef_1_d( double x, const double *parm ) { int i; 5771 AIR_UNUSED( parm ); /* TMF_d2_c1_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_c1_1ef( parm[0], i, x ); } static float _nrrd_TMF_d2_c1_1ef_1_f( float x, const double *parm ) { int i; 5782 AIR_UNUSED( parm ); /* TMF_d2_c1_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_c1_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_c1_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 5793 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c1_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_c1_1ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_c1_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 5808 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c1_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_c1_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_c1_1ef = { "TMF_d2_c1_1ef", 1, _nrrd_TMF_d2_c1_1ef_Sup, _nrrd_TMF_d2_c1_1ef_Int, _nrrd_TMF_d2_c1_1ef_1_f, _nrrd_TMF_d2_c1_1ef_N_f, _nrrd_TMF_d2_c1_1ef_1_d, _nrrd_TMF_d2_c1_1ef_N_d }; /* ------------------------ TMF_d2_c1_2ef --------------------- */ static double _nrrd_TMF_d2_c1_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 5833 return 0.0; } static double _nrrd_TMF_d2_c1_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 5838 return 3; } static double _nrrd_TMF_d2_c1_2ef_1_d( double x, const double *parm ) { int i; 5844 AIR_UNUSED( parm ); /* TMF_d2_c1_2ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_c1_2ef( parm[0], i, x ); } static float _nrrd_TMF_d2_c1_2ef_1_f( float x, const double *parm ) { int i; 5855 AIR_UNUSED( parm ); /* TMF_d2_c1_2ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_c1_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_c1_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 5866 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c1_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_c1_2ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_c1_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 5881 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c1_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_c1_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_c1_2ef = { "TMF_d2_c1_2ef", 1, _nrrd_TMF_d2_c1_2ef_Sup, _nrrd_TMF_d2_c1_2ef_Int, _nrrd_TMF_d2_c1_2ef_1_f, _nrrd_TMF_d2_c1_2ef_N_f, _nrrd_TMF_d2_c1_2ef_1_d, _nrrd_TMF_d2_c1_2ef_N_d }; /* ------------------------ TMF_d2_c1_3ef --------------------- */ static double _nrrd_TMF_d2_c1_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 5906 return 0.0; } static double _nrrd_TMF_d2_c1_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 5911 return 3; } static double _nrrd_TMF_d2_c1_3ef_1_d( double x, const double *parm ) { int i; 5917 AIR_UNUSED( parm ); /* TMF_d2_c1_3ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_c1_3ef( parm[0], i, x ); } static float _nrrd_TMF_d2_c1_3ef_1_f( float x, const double *parm ) { int i; 5928 AIR_UNUSED( parm ); /* TMF_d2_c1_3ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_c1_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_c1_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 5939 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c1_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_c1_3ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_c1_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 5954 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c1_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_c1_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_c1_3ef = { "TMF_d2_c1_3ef", 1, _nrrd_TMF_d2_c1_3ef_Sup, _nrrd_TMF_d2_c1_3ef_Int, _nrrd_TMF_d2_c1_3ef_1_f, _nrrd_TMF_d2_c1_3ef_N_f, _nrrd_TMF_d2_c1_3ef_1_d, _nrrd_TMF_d2_c1_3ef_N_d }; /* ------------------------ TMF_d2_c1_4ef --------------------- */ static double _nrrd_TMF_d2_c1_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 5979 return 0.0; } static double _nrrd_TMF_d2_c1_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 5984 return 4; } static double _nrrd_TMF_d2_c1_4ef_1_d( double x, const double *parm ) { int i; 5990 x += 4; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_c1_4ef( parm[0], i, x ); } static float _nrrd_TMF_d2_c1_4ef_1_f( float x, const double *parm ) { int i; 6001 x += 4; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_c1_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_c1_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 6012 size_t I; int i; for ( I=0; I<len; I++ ) { t = x[I] + 4; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_c1_4ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_c1_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 6027 size_t I; int i; for ( I=0; I<len; I++ ) { t = x[I] + 4; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_c1_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_c1_4ef = { "TMF_d2_c1_4ef", 1, _nrrd_TMF_d2_c1_4ef_Sup, _nrrd_TMF_d2_c1_4ef_Int, _nrrd_TMF_d2_c1_4ef_1_f, _nrrd_TMF_d2_c1_4ef_N_f, _nrrd_TMF_d2_c1_4ef_1_d, _nrrd_TMF_d2_c1_4ef_N_d }; /* ------------------------ TMF_d2_c2_1ef --------------------- */ static double _nrrd_TMF_d2_c2_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); 6052 return 0.0; } static double _nrrd_TMF_d2_c2_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 6057 return 2; } static double _nrrd_TMF_d2_c2_1ef_1_d( double x, const double *parm ) { int i; 6063 AIR_UNUSED( parm ); /* TMF_d2_c2_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_c2_1ef( parm[0], i, x ); } static float _nrrd_TMF_d2_c2_1ef_1_f( float x, const double *parm ) { int i; 6074 AIR_UNUSED( parm ); /* TMF_d2_c2_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_c2_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_c2_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 6085 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c2_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_c2_1ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_c2_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 6100 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c2_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_c2_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_c2_1ef = { "TMF_d2_c2_1ef", 1, _nrrd_TMF_d2_c2_1ef_Sup, _nrrd_TMF_d2_c2_1ef_Int, _nrrd_TMF_d2_c2_1ef_1_f, _nrrd_TMF_d2_c2_1ef_N_f, _nrrd_TMF_d2_c2_1ef_1_d, _nrrd_TMF_d2_c2_1ef_N_d }; /* ------------------------ TMF_d2_c2_2ef --------------------- */ static double _nrrd_TMF_d2_c2_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); 6125 return 0.0; } static double _nrrd_TMF_d2_c2_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 6130 return 3; } static double _nrrd_TMF_d2_c2_2ef_1_d( double x, const double *parm ) { int i; 6136 AIR_UNUSED( parm ); /* TMF_d2_c2_2ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_c2_2ef( parm[0], i, x ); } static float _nrrd_TMF_d2_c2_2ef_1_f( float x, const double *parm ) { int i; 6147 AIR_UNUSED( parm ); /* TMF_d2_c2_2ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_c2_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_c2_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 6158 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c2_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_c2_2ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_c2_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 6173 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c2_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_c2_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_c2_2ef = { "TMF_d2_c2_2ef", 1, _nrrd_TMF_d2_c2_2ef_Sup, _nrrd_TMF_d2_c2_2ef_Int, _nrrd_TMF_d2_c2_2ef_1_f, _nrrd_TMF_d2_c2_2ef_N_f, _nrrd_TMF_d2_c2_2ef_1_d, _nrrd_TMF_d2_c2_2ef_N_d }; /* ------------------------ TMF_d2_c2_3ef --------------------- */ static double _nrrd_TMF_d2_c2_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); 6198 return 0.0; } static double _nrrd_TMF_d2_c2_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 6203 return 3; } static double _nrrd_TMF_d2_c2_3ef_1_d( double x, const double *parm ) { int i; 6209 AIR_UNUSED( parm ); /* TMF_d2_c2_3ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_c2_3ef( parm[0], i, x ); } static float _nrrd_TMF_d2_c2_3ef_1_f( float x, const double *parm ) { int i; 6220 AIR_UNUSED( parm ); /* TMF_d2_c2_3ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_c2_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_c2_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 6231 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c2_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_c2_3ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_c2_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 6246 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c2_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_c2_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_c2_3ef = { "TMF_d2_c2_3ef", 1, _nrrd_TMF_d2_c2_3ef_Sup, _nrrd_TMF_d2_c2_3ef_Int, _nrrd_TMF_d2_c2_3ef_1_f, _nrrd_TMF_d2_c2_3ef_N_f, _nrrd_TMF_d2_c2_3ef_1_d, _nrrd_TMF_d2_c2_3ef_N_d }; /* ------------------------ TMF_d2_c2_4ef --------------------- */ static double _nrrd_TMF_d2_c2_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); 6271 return 0.0; } static double _nrrd_TMF_d2_c2_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); 6276 return 4; } static double _nrrd_TMF_d2_c2_4ef_1_d( double x, const double *parm ) { int i; 6282 AIR_UNUSED( parm ); /* TMF_d2_c2_4ef */ x += 4; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_c2_4ef( parm[0], i, x ); } static float _nrrd_TMF_d2_c2_4ef_1_f( float x, const double *parm ) { int i; 6293 AIR_UNUSED( parm ); /* TMF_d2_c2_4ef */ x += 4; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_c2_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_c2_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; 6304 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c2_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 4; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_c2_4ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_c2_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; 6319 size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c2_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 4; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_c2_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_c2_4ef = { "TMF_d2_c2_4ef", 1, _nrrd_TMF_d2_c2_4ef_Sup, _nrrd_TMF_d2_c2_4ef_Int, _nrrd_TMF_d2_c2_4ef_1_f, _nrrd_TMF_d2_c2_4ef_N_f, _nrrd_TMF_d2_c2_4ef_1_d, _nrrd_TMF_d2_c2_4ef_N_d }; /* ------------------------ TMF_d2_c3_1ef --------------------- */ 6342 static double _nrrd_TMF_d2_c3_1ef_Int( const double *parm ) { AIR_UNUSED( parm ); return 0.0; } static double _nrrd_TMF_d2_c3_1ef_Sup( const double *parm ) { AIR_UNUSED( parm ); return 2; } static double _nrrd_TMF_d2_c3_1ef_1_d( double x, const double *parm ) { int i; AIR_UNUSED( parm ); /* TMF_d2_c3_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_c3_1ef( parm[0], i, x ); } static float _nrrd_TMF_d2_c3_1ef_1_f( float x, const double *parm ) { int i; AIR_UNUSED( parm ); /* TMF_d2_c3_1ef */ x += 2; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_c3_1ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_c3_1ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c3_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_c3_1ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_c3_1ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c3_1ef */ for ( I=0; I<len; I++ ) { t = x[I] + 2; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_c3_1ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_c3_1ef = { "TMF_d2_c3_1ef", 1, _nrrd_TMF_d2_c3_1ef_Sup, _nrrd_TMF_d2_c3_1ef_Int, _nrrd_TMF_d2_c3_1ef_1_f, _nrrd_TMF_d2_c3_1ef_N_f, _nrrd_TMF_d2_c3_1ef_1_d, _nrrd_TMF_d2_c3_1ef_N_d }; /* ------------------------ TMF_d2_c3_2ef --------------------- */ static double _nrrd_TMF_d2_c3_2ef_Int( const double *parm ) { AIR_UNUSED( parm ); return 0.0; } static double _nrrd_TMF_d2_c3_2ef_Sup( const double *parm ) { AIR_UNUSED( parm ); return 3; } static double _nrrd_TMF_d2_c3_2ef_1_d( double x, const double *parm ) { int i; AIR_UNUSED( parm ); /* TMF_d2_c3_2ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_c3_2ef( parm[0], i, x ); } static float _nrrd_TMF_d2_c3_2ef_1_f( float x, const double *parm ) { int i; AIR_UNUSED( parm ); /* TMF_d2_c3_2ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_c3_2ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_c3_2ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c3_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_c3_2ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_c3_2ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c3_2ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_c3_2ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_c3_2ef = { "TMF_d2_c3_2ef", 1, _nrrd_TMF_d2_c3_2ef_Sup, _nrrd_TMF_d2_c3_2ef_Int, _nrrd_TMF_d2_c3_2ef_1_f, _nrrd_TMF_d2_c3_2ef_N_f, _nrrd_TMF_d2_c3_2ef_1_d, _nrrd_TMF_d2_c3_2ef_N_d }; /* ------------------------ TMF_d2_c3_3ef --------------------- */ static double _nrrd_TMF_d2_c3_3ef_Int( const double *parm ) { AIR_UNUSED( parm ); return 0.0; } static double _nrrd_TMF_d2_c3_3ef_Sup( const double *parm ) { AIR_UNUSED( parm ); return 3; } static double _nrrd_TMF_d2_c3_3ef_1_d( double x, const double *parm ) { int i; AIR_UNUSED( parm ); /* TMF_d2_c3_3ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_c3_3ef( parm[0], i, x ); } static float _nrrd_TMF_d2_c3_3ef_1_f( float x, const double *parm ) { int i; AIR_UNUSED( parm ); /* TMF_d2_c3_3ef */ x += 3; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_c3_3ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_c3_3ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c3_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_c3_3ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_c3_3ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c3_3ef */ for ( I=0; I<len; I++ ) { t = x[I] + 3; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_c3_3ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_c3_3ef = { "TMF_d2_c3_3ef", 1, _nrrd_TMF_d2_c3_3ef_Sup, _nrrd_TMF_d2_c3_3ef_Int, _nrrd_TMF_d2_c3_3ef_1_f, _nrrd_TMF_d2_c3_3ef_N_f, _nrrd_TMF_d2_c3_3ef_1_d, _nrrd_TMF_d2_c3_3ef_N_d }; /* ------------------------ TMF_d2_c3_4ef --------------------- */ static double _nrrd_TMF_d2_c3_4ef_Int( const double *parm ) { AIR_UNUSED( parm ); return 0.0; } static double _nrrd_TMF_d2_c3_4ef_Sup( const double *parm ) { AIR_UNUSED( parm ); return 4; } static double _nrrd_TMF_d2_c3_4ef_1_d( double x, const double *parm ) { int i; AIR_UNUSED( parm ); /* TMF_d2_c3_4ef */ x += 4; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= i; return TMF_d2_c3_4ef( parm[0], i, x ); } static float _nrrd_TMF_d2_c3_4ef_1_f( float x, const double *parm ) { int i; AIR_UNUSED( parm ); /* TMF_d2_c3_4ef */ x += 4; i = ( int )( ( x<0 ) ? x-1 : x ); /* HEY scrutinize cast */ x -= AIR_CAST( float, i ); return AIR_CAST( float, TMF_d2_c3_4ef( parm[0], i, x ) ); } static void _nrrd_TMF_d2_c3_4ef_N_d( double *f, const double *x, size_t len, const double *parm ) { double t; size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c3_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 4; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= i; f[I] = TMF_d2_c3_4ef( parm[0], i, t ); } } static void _nrrd_TMF_d2_c3_4ef_N_f( float *f, const float *x, size_t len, const double *parm ) { float t; size_t I; int i; AIR_UNUSED( parm ); /* TMF_d2_c3_4ef */ for ( I=0; I<len; I++ ) { t = x[I] + 4; i = ( int )( ( t<0 ) ? t-1 : t ); /* HEY scrutinize cast */ t -= AIR_CAST( float, i ); f[I] = AIR_CAST( float, TMF_d2_c3_4ef( parm[0], i, t ) ); } } static NrrdKernel _nrrdKernel_TMF_d2_c3_4ef = { "TMF_d2_c3_4ef", 1, _nrrd_TMF_d2_c3_4ef_Sup, _nrrd_TMF_d2_c3_4ef_Int, _nrrd_TMF_d2_c3_4ef_1_f, _nrrd_TMF_d2_c3_4ef_N_f, _nrrd_TMF_d2_c3_4ef_1_d, _nrrd_TMF_d2_c3_4ef_N_d }; NrrdKernel *const nrrdKernelTMF[4][5][5] = { { /* d = n */ { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_dn_cn_1ef, &_nrrdKernel_TMF_dn_cn_2ef, &_nrrdKernel_TMF_dn_cn_3ef, &_nrrdKernel_TMF_dn_cn_4ef, }, { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_dn_c0_1ef, &_nrrdKernel_TMF_dn_c0_2ef, &_nrrdKernel_TMF_dn_c0_3ef, &_nrrdKernel_TMF_dn_c0_4ef, }, { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_dn_c1_1ef, &_nrrdKernel_TMF_dn_c1_2ef, &_nrrdKernel_TMF_dn_c1_3ef, &_nrrdKernel_TMF_dn_c1_4ef, }, { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_dn_c2_1ef, &_nrrdKernel_TMF_dn_c2_2ef, &_nrrdKernel_TMF_dn_c2_3ef, &_nrrdKernel_TMF_dn_c2_4ef, }, { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_dn_c3_1ef, &_nrrdKernel_TMF_dn_c3_2ef, &_nrrdKernel_TMF_dn_c3_3ef, &_nrrdKernel_TMF_dn_c3_4ef, }, }, { /* d = 0 */ { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_d0_cn_1ef, &_nrrdKernel_TMF_d0_cn_2ef, &_nrrdKernel_TMF_d0_cn_3ef, &_nrrdKernel_TMF_d0_cn_4ef, }, { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_d0_c0_1ef, &_nrrdKernel_TMF_d0_c0_2ef, &_nrrdKernel_TMF_d0_c0_3ef, &_nrrdKernel_TMF_d0_c0_4ef, }, { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_d0_c1_1ef, &_nrrdKernel_TMF_d0_c1_2ef, &_nrrdKernel_TMF_d0_c1_3ef, &_nrrdKernel_TMF_d0_c1_4ef, }, { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_d0_c2_1ef, &_nrrdKernel_TMF_d0_c2_2ef, &_nrrdKernel_TMF_d0_c2_3ef, &_nrrdKernel_TMF_d0_c2_4ef, }, { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_d0_c3_1ef, &_nrrdKernel_TMF_d0_c3_2ef, &_nrrdKernel_TMF_d0_c3_3ef, &_nrrdKernel_TMF_d0_c3_4ef, }, }, { /* d = 1 */ { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_d1_cn_1ef, &_nrrdKernel_TMF_d1_cn_2ef, &_nrrdKernel_TMF_d1_cn_3ef, &_nrrdKernel_TMF_d1_cn_4ef, }, { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_d1_c0_1ef, &_nrrdKernel_TMF_d1_c0_2ef, &_nrrdKernel_TMF_d1_c0_3ef, &_nrrdKernel_TMF_d1_c0_4ef, }, { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_d1_c1_1ef, &_nrrdKernel_TMF_d1_c1_2ef, &_nrrdKernel_TMF_d1_c1_3ef, &_nrrdKernel_TMF_d1_c1_4ef, }, { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_d1_c2_1ef, &_nrrdKernel_TMF_d1_c2_2ef, &_nrrdKernel_TMF_d1_c2_3ef, &_nrrdKernel_TMF_d1_c2_4ef, }, { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_d1_c3_1ef, &_nrrdKernel_TMF_d1_c3_2ef, &_nrrdKernel_TMF_d1_c3_3ef, &_nrrdKernel_TMF_d1_c3_4ef, }, }, { /* d = 2 */ { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_d2_cn_1ef, &_nrrdKernel_TMF_d2_cn_2ef, &_nrrdKernel_TMF_d2_cn_3ef, &_nrrdKernel_TMF_d2_cn_4ef, }, { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_d2_c0_1ef, &_nrrdKernel_TMF_d2_c0_2ef, &_nrrdKernel_TMF_d2_c0_3ef, &_nrrdKernel_TMF_d2_c0_4ef, }, { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_d2_c1_1ef, &_nrrdKernel_TMF_d2_c1_2ef, &_nrrdKernel_TMF_d2_c1_3ef, &_nrrdKernel_TMF_d2_c1_4ef, }, { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_d2_c2_1ef, &_nrrdKernel_TMF_d2_c2_2ef, &_nrrdKernel_TMF_d2_c2_3ef, &_nrrdKernel_TMF_d2_c2_4ef, }, { &_nrrdKernel_TMFBAD, &_nrrdKernel_TMF_d2_c3_1ef, &_nrrdKernel_TMF_d2_c3_2ef, &_nrrdKernel_TMF_d2_c3_3ef, &_nrrdKernel_TMF_d2_c3_4ef, }, }, }; const unsigned int nrrdKernelTMF_maxD = 2; const unsigned int nrrdKernelTMF_maxC = 3; const unsigned int nrrdKernelTMF_maxA = 4;

/Users/scm/git/github/teem/src/nrrd/winKernel.c

/Users/scm/git/github/teem/src/nrrd/write.c

/Users/scm/git/github/teem/src/preamble.c

/Users/scm/git/github/teem/src/pull/actionPull.c

/Users/scm/git/github/teem/src/pull/binningPull.c

/Users/scm/git/github/teem/src/pull/ccPull.c

/Users/scm/git/github/teem/src/pull/constraints.c

/Users/scm/git/github/teem/src/pull/contextPull.c

/Users/scm/git/github/teem/src/pull/corePull.c

/Users/scm/git/github/teem/src/pull/defaultsPull.c

/Users/scm/git/github/teem/src/pull/energy.c

/Users/scm/git/github/teem/src/pull/enumsPull.c

/Users/scm/git/github/teem/src/pull/infoPull.c

/Users/scm/git/github/teem/src/pull/initPull.c

/Users/scm/git/github/teem/src/pull/parmPull.c

/Users/scm/git/github/teem/src/pull/pointPull.c

/Users/scm/git/github/teem/src/pull/popcntl.c

/Users/scm/git/github/teem/src/pull/taskPull.c

/Users/scm/git/github/teem/src/pull/test/circ.c

/Users/scm/git/github/teem/src/pull/test/eparse.c

/Users/scm/git/github/teem/src/pull/trace.c

/Users/scm/git/github/teem/src/pull/volumePull.c

/Users/scm/git/github/teem/src/push/action.c

/Users/scm/git/github/teem/src/push/binning.c

/Users/scm/git/github/teem/src/push/corePush.c

/Users/scm/git/github/teem/src/push/defaultsPush.c

/Users/scm/git/github/teem/src/push/forces.c

/Users/scm/git/github/teem/src/push/methodsPush.c

/Users/scm/git/github/teem/src/push/setup.c

/Users/scm/git/github/teem/src/push/test/eparse.c

/Users/scm/git/github/teem/src/push/test/pusher.c

/Users/scm/git/github/teem/src/seek/descend.c

/Users/scm/git/github/teem/src/seek/enumsSeek.c

/Users/scm/git/github/teem/src/seek/extract.c

/Users/scm/git/github/teem/src/seek/methodsSeek.c

/Users/scm/git/github/teem/src/seek/setSeek.c

/Users/scm/git/github/teem/src/seek/tables.c

1 /* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2010, 2009 Thomas Schultz Copyright ( C ) 2008, 2007, 2006, 2005 Gordon Kindlmann Copyright ( C ) 2004, 2003, 2002, 2001, 2000, 1999, 1998 University of Utah This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "seek.h" /* ** vertex, edge, and face numbering, and canonical edge arrangement ** ** Z ** ^ Y ** | ^ ** | / ** | / ** |/ ** O--------> X ** ** ( 6 )---11---( 7 ) +----------+ +----------+ ** /| /| /| /| /| \ /| ** 9 | 10 | / | /5/ / | / | \/ | ** / 6 / 7 / | |4|/ | / \| /\ | ** ( 4 )----8---( 5 ) | +----------+ | +----------+ | ** | | | | ||2|| ||3|| | | \ | | ** | ( 2 )---3-|--( 3 ) | +------|---+ | +----\-|---+ ** 4 / 5 / | / |1| | / |\ / |\ / ** | 1 | 2 | / /0/ | / | /\ | / ** |/ |/ |/ |/ |/ \ |/ ** ( 0 )----0---( 1 ) +----------+ +----------+ ** canonical edge arrangement ** creates 2 triangular and ** 1 hexagonal surface */ /* According to this layout, in the code comments, "right" denotes * positive x, "back" denotes positive y, "top" denotes positive z */ /* ** the seekContext's vidx cache uses this numbering ** ( . )--------( . ) ** /| /| ** 4 | / | ** / | / | ** ( . )----3---( . ) | ** | | | | ** | ( . )-----|--( . ) ** 2 / | / ** | 1 | / ** |/ |/ ** ( X )----0---( . ) */ /* We now only need a numbering of faces. It is: * 0: xy plane, z=0 * 1: xz plane, y=0 * 2: yz plane, x=1 * 3: xz plane, y=1 * 4: yz plane, x=0 * 5: xy plane, z=1 * * There are four unique faces to each voxel ( e.g., in facevidx ): * 0: xy plane, z=0 * 1: xz plane, y=0 * 2: yz plane, x=0 * 3: xy plane, z=1 */ const int seekContour3DTopoHackEdge[256] = { 0x000, 0x013, 0x025, 0x036, 0x04A, 0x059, 0x06F, 0x07C, 0x08C, 0x09F, 0x0A9, 0x0BA, 0x0C6, 0x0D5, 0x0E3, 0x0F0, 0x310, 0x303, 0x335, 0x326, 0x35A, 0x349, 0x37F, 0x36C, 0x39C, 0x38F, 0x3B9, 0x3AA, 0x3D6, 0x3C5, 0x3F3, 0x3E0, 0x520, 0x533, 0x505, 0x516, 0x56A, 0x579, 0x54F, 0x55C, 0x5AC, 0x5BF, 0x589, 0x59A, 0x5E6, 0x5F5, 0x5C3, 0x5D0, 0x630, 0x623, 0x615, 0x606, 0x67A, 0x669, 0x65F, 0x64C, 0x6BC, 0x6AF, 0x699, 0x68A, 0x6F6, 0x6E5, 0x6D3, 0x6C0, 0xA40, 0xA53, 0xA65, 0xA76, 0xA0A, 0xA19, 0xA2F, 0xA3C, 0xACC, 0xADF, 0xAE9, 0xAFA, 0xA86, 0xA95, 0xAA3, 0xAB0, 0x950, 0x943, 0x975, 0x966, 0x91A, 0x909, 0x93F, 0x92C, 0x9DC, 0x9CF, 0x9F9, 0x9EA, 0x996, 0x985, 0x9B3, 0x9A0, 0xF60, 0xF73, 0xF45, 0xF56, 0xF2A, 0xF39, 0xF0F, 0xF1C, 0xFEC, 0xFFF, 0xFC9, 0xFDA, 0xFA6, 0xFB5, 0xF83, 0xF90, 0xC70, 0xC63, 0xC55, 0xC46, 0xC3A, 0xC29, 0xC1F, 0xC0C, 0xCFC, 0xCEF, 0xCD9, 0xCCA, 0xCB6, 0xCA5, 0xC93, 0xC80, 0xC80, 0xC93, 0xCA5, 0xCB6, 0xCCA, 0xCD9, 0xCEF, 0xCFC, 0xC0C, 0xC1F, 0xC29, 0xC3A, 0xC46, 0xC55, 0xC63, 0xC70, 0xF90, 0xF83, 0xFB5, 0xFA6, 0xFDA, 0xFC9, 0xFFF, 0xFEC, 0xF1C, 0xF0F, 0xF39, 0xF2A, 0xF56, 0xF45, 0xF73, 0xF60, 0x9A0, 0x9B3, 0x985, 0x996, 0x9EA, 0x9F9, 0x9CF, 0x9DC, 0x92C, 0x93F, 0x909, 0x91A, 0x966, 0x975, 0x943, 0x950, 0xAB0, 0xAA3, 0xA95, 0xA86, 0xAFA, 0xAE9, 0xADF, 0xACC, 0xA3C, 0xA2F, 0xA19, 0xA0A, 0xA76, 0xA65, 0xA53, 0xA40, 0x6C0, 0x6D3, 0x6E5, 0x6F6, 0x68A, 0x699, 0x6AF, 0x6BC, 0x64C, 0x65F, 0x669, 0x67A, 0x606, 0x615, 0x623, 0x630, 0x5D0, 0x5C3, 0x5F5, 0x5E6, 0x59A, 0x589, 0x5BF, 0x5AC, 0x55C, 0x54F, 0x579, 0x56A, 0x516, 0x505, 0x533, 0x520, 0x3E0, 0x3F3, 0x3C5, 0x3D6, 0x3AA, 0x3B9, 0x38F, 0x39C, 0x36C, 0x37F, 0x349, 0x35A, 0x326, 0x335, 0x303, 0x310, 0x0F0, 0x0E3, 0x0D5, 0x0C6, 0x0BA, 0x0A9, 0x09F, 0x08C, 0x07C, 0x06F, 0x059, 0x04A, 0x036, 0x025, 0x013, 0x000 }; /* This case table implements the ideas from Dietrich et al. Edge Groups: an approach to understanding the mesh quality of marching methods. IEEE Trans. Vis. Comp. Graph. 2008 and has been generated from the case table distributed with macet, written by Carlos Dietrich. Re-used with kind permission of the authors. */ const int seekContour3DTopoHackTriangle[256][16] = { {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 0, 1, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 5, 2, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 5, 2, 4, 4, 2, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 1, 3, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 4, 0, 6, 6, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 3, 6, 1, 5, 2, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 6, 4, 3, 4, 2, 3, 4, 5, 2, -1, -1, -1, -1, -1, -1, -1}, { 2, 7, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 1, 4, 0, 7, 3, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 0, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 4, 5, 1, 5, 3, 1, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1}, { 6, 1, 7, 7, 1, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 7, 6, 2, 6, 0, 2, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1}, { 5, 7, 0, 7, 1, 0, 7, 6, 1, -1, -1, -1, -1, -1, -1, -1}, { 5, 6, 4, 5, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 9, 8, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 0, 1, 8, 8, 1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 4, 9, 8, 2, 0, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 2, 1, 5, 1, 8, 5, 1, 9, 8, -1, -1, -1, -1, -1, -1, -1}, { 9, 8, 4, 3, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 8, 0, 9, 0, 6, 9, 0, 3, 6, -1, -1, -1, -1, -1, -1, -1}, { 8, 4, 9, 3, 6, 1, 2, 0, 5, -1, -1, -1, -1, -1, -1, -1}, { 2, 3, 6, 2, 6, 9, 5, 2, 9, 8, 5, 9, -1, -1, -1, -1}, { 9, 8, 4, 7, 3, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 9, 8, 1, 8, 0, 1, 7, 3, 2, -1, -1, -1, -1, -1, -1, -1}, { 7, 3, 5, 3, 0, 5, 9, 8, 4, -1, -1, -1, -1, -1, -1, -1}, { 5, 7, 8, 8, 7, 3, 1, 9, 8, 1, 8, 3, -1, -1, -1, -1}, { 2, 7, 1, 7, 6, 1, 8, 4, 9, -1, -1, -1, -1, -1, -1, -1}, { 7, 6, 9, 9, 0, 2, 8, 0, 9, 7, 9, 2, -1, -1, -1, -1}, { 4, 9, 8, 7, 6, 1, 0, 7, 1, 5, 7, 0, -1, -1, -1, -1}, { 7, 6, 9, 8, 7, 9, 5, 7, 8, -1, -1, -1, -1, -1, -1, -1}, {10, 5, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 0, 1, 4, 10, 5, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 8, 10, 0, 0, 10, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, {10, 2, 8, 2, 4, 8, 2, 1, 4, -1, -1, -1, -1, -1, -1, -1}, {10, 5, 8, 3, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 3, 6, 0, 6, 4, 0, 10, 5, 8, -1, -1, -1, -1, -1, -1, -1}, { 8, 10, 0, 10, 2, 0, 6, 1, 3, -1, -1, -1, -1, -1, -1, -1}, {10, 2, 8, 8, 2, 3, 6, 4, 8, 6, 8, 3, -1, -1, -1, -1}, { 5, 8, 10, 3, 2, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, {10, 5, 8, 1, 4, 0, 3, 2, 7, -1, -1, -1, -1, -1, -1, -1}, { 3, 0, 7, 0, 10, 7, 0, 8, 10, -1, -1, -1, -1, -1, -1, -1}, { 7, 3, 10, 10, 3, 8, 3, 1, 8, 1, 4, 8, -1, -1, -1, -1}, { 6, 1, 7, 1, 2, 7, 8, 10, 5, -1, -1, -1, -1, -1, -1, -1}, {10, 5, 8, 6, 4, 0, 2, 6, 0, 7, 6, 2, -1, -1, -1, -1}, { 0, 8, 1, 1, 8, 10, 7, 6, 1, 7, 1, 10, -1, -1, -1, -1}, { 6, 4, 8, 10, 6, 8, 7, 6, 10, -1, -1, -1, -1, -1, -1, -1}, {10, 5, 9, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 1, 9, 0, 9, 5, 0, 9, 10, 5, -1, -1, -1, -1, -1, -1, -1}, { 9, 10, 4, 10, 0, 4, 10, 2, 0, -1, -1, -1, -1, -1, -1, -1}, {10, 1, 9, 2, 1, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, {10, 5, 9, 5, 4, 9, 3, 6, 1, -1, -1, -1, -1, -1, -1, -1}, { 9, 10, 5, 5, 3, 6, 0, 3, 5, 9, 5, 6, -1, -1, -1, -1}, { 1, 3, 6, 10, 2, 0, 4, 10, 0, 9, 10, 4, -1, -1, -1, -1}, {10, 2, 3, 6, 10, 3, 9, 10, 6, -1, -1, -1, -1, -1, -1, -1}, { 4, 9, 5, 9, 10, 5, 3, 2, 7, -1, -1, -1, -1, -1, -1, -1}, { 3, 2, 7, 9, 10, 5, 0, 9, 5, 1, 9, 0, -1, -1, -1, -1}, { 3, 0, 4, 4, 10, 7, 9, 10, 4, 3, 4, 7, -1, -1, -1, -1}, { 9, 10, 7, 3, 9, 7, 1, 9, 3, -1, -1, -1, -1, -1, -1, -1}, { 1, 2, 6, 2, 7, 6, 9, 5, 4, 9, 10, 5, -1, -1, -1, -1}, { 9, 10, 5, 0, 9, 5, 0, 6, 9, 2, 6, 0, 7, 6, 2, -1}, { 7, 6, 1, 0, 7, 1, 0, 10, 7, 4, 10, 0, 9, 10, 4, -1}, { 6, 9, 10, 6, 10, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 6, 11, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 6, 11, 9, 0, 1, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 6, 11, 9, 2, 0, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 5, 2, 4, 2, 1, 4, 11, 9, 6, -1, -1, -1, -1, -1, -1, -1}, { 1, 3, 9, 9, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 0, 3, 4, 3, 9, 4, 3, 11, 9, -1, -1, -1, -1, -1, -1, -1}, {11, 9, 3, 9, 1, 3, 5, 2, 0, -1, -1, -1, -1, -1, -1, -1}, { 3, 11, 9, 9, 5, 2, 4, 5, 9, 3, 9, 2, -1, -1, -1, -1}, {11, 9, 6, 2, 7, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 0, 1, 4, 11, 9, 6, 7, 3, 2, -1, -1, -1, -1, -1, -1, -1}, { 0, 5, 3, 5, 7, 3, 9, 6, 11, -1, -1, -1, -1, -1, -1, -1}, { 6, 11, 9, 5, 7, 3, 1, 5, 3, 4, 5, 1, -1, -1, -1, -1}, { 9, 1, 11, 1, 7, 11, 1, 2, 7, -1, -1, -1, -1, -1, -1, -1}, { 2, 7, 0, 0, 7, 4, 7, 11, 4, 11, 9, 4, -1, -1, -1, -1}, { 9, 1, 11, 11, 1, 0, 5, 7, 11, 5, 11, 0, -1, -1, -1, -1}, { 5, 7, 11, 9, 5, 11, 4, 5, 9, -1, -1, -1, -1, -1, -1, -1}, { 6, 11, 4, 4, 11, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, {11, 8, 6, 8, 1, 6, 8, 0, 1, -1, -1, -1, -1, -1, -1, -1}, { 6, 11, 4, 11, 8, 4, 2, 0, 5, -1, -1, -1, -1, -1, -1, -1}, {11, 8, 5, 5, 1, 6, 2, 1, 5, 11, 5, 6, -1, -1, -1, -1}, { 3, 11, 1, 11, 4, 1, 11, 8, 4, -1, -1, -1, -1, -1, -1, -1}, { 0, 11, 8, 3, 11, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 2, 0, 5, 11, 8, 4, 1, 11, 4, 3, 11, 1, -1, -1, -1, -1}, {11, 8, 5, 2, 11, 5, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1}, { 8, 4, 11, 4, 6, 11, 2, 7, 3, -1, -1, -1, -1, -1, -1, -1}, { 7, 3, 2, 8, 0, 1, 6, 8, 1, 11, 8, 6, -1, -1, -1, -1}, { 5, 7, 0, 7, 3, 0, 4, 11, 8, 4, 6, 11, -1, -1, -1, -1}, { 3, 5, 7, 1, 5, 3, 1, 8, 5, 6, 8, 1, 11, 8, 6, -1}, { 1, 2, 4, 4, 2, 7, 11, 8, 4, 11, 4, 7, -1, -1, -1, -1}, { 8, 0, 2, 7, 8, 2, 11, 8, 7, -1, -1, -1, -1, -1, -1, -1}, {11, 8, 4, 1, 11, 4, 1, 7, 11, 0, 7, 1, 5, 7, 0, -1}, { 7, 11, 8, 7, 8, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, {10, 5, 8, 6, 11, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 1, 4, 0, 10, 5, 8, 11, 9, 6, -1, -1, -1, -1, -1, -1, -1}, { 2, 0, 10, 0, 8, 10, 6, 11, 9, -1, -1, -1, -1, -1, -1, -1}, {11, 9, 6, 2, 1, 4, 8, 2, 4, 10, 2, 8, -1, -1, -1, -1}, { 1, 3, 9, 3, 11, 9, 5, 8, 10, -1, -1, -1, -1, -1, -1, -1}, { 5, 8, 10, 3, 11, 9, 4, 3, 9, 0, 3, 4, -1, -1, -1, -1}, { 1, 11, 9, 3, 11, 1, 0, 8, 10, 2, 0, 10, -1, -1, -1, -1}, { 3, 11, 9, 4, 3, 9, 4, 2, 3, 8, 2, 4, 10, 2, 8, -1}, { 6, 11, 9, 5, 8, 10, 2, 7, 3, -1, -1, -1, -1, -1, -1, -1}, { 3, 2, 7, 10, 5, 8, 0, 1, 4, 11, 9, 6, -1, -1, -1, -1}, { 6, 11, 9, 0, 8, 10, 7, 0, 10, 3, 0, 7, -1, -1, -1, -1}, {10, 7, 8, 7, 3, 8, 3, 4, 8, 4, 3, 1, 6, 11, 9, -1}, {10, 5, 8, 1, 2, 7, 11, 1, 7, 9, 1, 11, -1, -1, -1, -1}, { 0, 2, 4, 2, 7, 4, 7, 9, 4, 9, 7, 11, 10, 5, 8, -1}, {10, 0, 8, 7, 0, 10, 7, 1, 0, 11, 1, 7, 9, 1, 11, -1}, { 4, 8, 10, 7, 4, 10, 4, 11, 9, 4, 7, 11, -1, -1, -1, -1}, { 5, 4, 10, 4, 11, 10, 4, 6, 11, -1, -1, -1, -1, -1, -1, -1}, {11, 10, 5, 11, 5, 0, 6, 11, 0, 1, 6, 0, -1, -1, -1, -1}, { 4, 6, 11, 11, 2, 0, 10, 2, 11, 4, 11, 0, -1, -1, -1, -1}, { 2, 1, 6, 11, 2, 6, 10, 2, 11, -1, -1, -1, -1, -1, -1, -1}, { 5, 4, 1, 1, 11, 10, 3, 11, 1, 5, 1, 10, -1, -1, -1, -1}, { 3, 11, 10, 5, 3, 10, 0, 3, 5, -1, -1, -1, -1, -1, -1, -1}, {10, 2, 0, 4, 10, 0, 4, 11, 10, 1, 11, 4, 3, 11, 1, -1}, {11, 10, 2, 11, 2, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 2, 7, 3, 4, 6, 11, 10, 4, 11, 5, 4, 10, -1, -1, -1, -1}, { 1, 6, 0, 6, 11, 0, 11, 5, 0, 5, 11, 10, 7, 3, 2, -1}, {11, 4, 6, 10, 4, 11, 10, 0, 4, 7, 0, 10, 3, 0, 7, -1}, {10, 7, 3, 1, 10, 3, 10, 6, 11, 10, 1, 6, -1, -1, -1, -1}, { 1, 2, 7, 11, 1, 7, 11, 4, 1, 10, 4, 11, 5, 4, 10, -1}, { 0, 2, 7, 11, 0, 7, 0, 10, 5, 0, 11, 10, -1, -1, -1, -1}, { 1, 0, 4, 10, 7, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 7, 11, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, {11, 7, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 0, 1, 4, 7, 10, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 2, 0, 5, 11, 7, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 1, 4, 2, 4, 5, 2, 11, 7, 10, -1, -1, -1, -1, -1, -1, -1}, { 7, 10, 11, 1, 3, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 4, 0, 6, 0, 3, 6, 10, 11, 7, -1, -1, -1, -1, -1, -1, -1}, { 5, 2, 0, 6, 1, 3, 11, 7, 10, -1, -1, -1, -1, -1, -1, -1}, { 7, 10, 11, 4, 5, 2, 3, 4, 2, 6, 4, 3, -1, -1, -1, -1}, {10, 11, 2, 2, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, {10, 11, 2, 11, 3, 2, 4, 0, 1, -1, -1, -1, -1, -1, -1, -1}, {11, 3, 10, 3, 5, 10, 3, 0, 5, -1, -1, -1, -1, -1, -1, -1}, { 4, 5, 1, 1, 5, 10, 11, 3, 1, 11, 1, 10, -1, -1, -1, -1}, { 1, 2, 6, 2, 11, 6, 2, 10, 11, -1, -1, -1, -1, -1, -1, -1}, { 6, 4, 11, 11, 4, 0, 2, 10, 11, 2, 11, 0, -1, -1, -1, -1}, {10, 11, 5, 5, 11, 0, 11, 6, 0, 6, 1, 0, -1, -1, -1, -1}, { 4, 5, 10, 11, 4, 10, 6, 4, 11, -1, -1, -1, -1, -1, -1, -1}, { 8, 4, 9, 7, 10, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 0, 1, 8, 1, 9, 8, 7, 10, 11, -1, -1, -1, -1, -1, -1, -1}, { 9, 8, 4, 2, 0, 5, 7, 10, 11, -1, -1, -1, -1, -1, -1, -1}, { 7, 10, 11, 1, 9, 8, 5, 1, 8, 2, 1, 5, -1, -1, -1, -1}, { 4, 9, 8, 7, 10, 11, 3, 6, 1, -1, -1, -1, -1, -1, -1, -1}, {11, 7, 10, 0, 3, 6, 9, 0, 6, 8, 0, 9, -1, -1, -1, -1}, { 9, 8, 4, 1, 3, 6, 2, 0, 5, 7, 10, 11, -1, -1, -1, -1}, { 8, 5, 9, 5, 2, 9, 2, 6, 9, 6, 2, 3, 7, 10, 11, -1}, { 3, 2, 11, 2, 10, 11, 4, 9, 8, -1, -1, -1, -1, -1, -1, -1}, {11, 3, 10, 3, 2, 10, 8, 1, 9, 8, 0, 1, -1, -1, -1, -1}, { 8, 4, 9, 3, 0, 5, 10, 3, 5, 11, 3, 10, -1, -1, -1, -1}, { 1, 9, 8, 5, 1, 8, 5, 3, 1, 10, 3, 5, 11, 3, 10, -1}, { 9, 8, 4, 2, 10, 11, 6, 2, 11, 1, 2, 6, -1, -1, -1, -1}, { 2, 10, 11, 6, 2, 11, 6, 0, 2, 9, 0, 6, 8, 0, 9, -1}, { 5, 10, 0, 10, 11, 0, 11, 1, 0, 1, 11, 6, 9, 8, 4, -1}, { 5, 10, 11, 6, 5, 11, 5, 9, 8, 5, 6, 9, -1, -1, -1, -1}, {11, 7, 8, 8, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, {11, 7, 8, 7, 5, 8, 1, 4, 0, -1, -1, -1, -1, -1, -1, -1}, { 0, 8, 2, 8, 7, 2, 8, 11, 7, -1, -1, -1, -1, -1, -1, -1}, { 2, 1, 4, 4, 11, 7, 8, 11, 4, 2, 4, 7, -1, -1, -1, -1}, { 5, 8, 7, 8, 11, 7, 1, 3, 6, -1, -1, -1, -1, -1, -1, -1}, {11, 5, 8, 7, 5, 11, 6, 4, 0, 3, 6, 0, -1, -1, -1, -1}, { 3, 6, 1, 8, 11, 7, 2, 8, 7, 0, 8, 2, -1, -1, -1, -1}, { 8, 11, 7, 2, 8, 7, 2, 4, 8, 3, 4, 2, 6, 4, 3, -1}, { 8, 11, 5, 11, 2, 5, 11, 3, 2, -1, -1, -1, -1, -1, -1, -1}, { 0, 1, 4, 11, 3, 2, 5, 11, 2, 8, 11, 5, -1, -1, -1, -1}, {11, 0, 8, 11, 3, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, {11, 3, 1, 4, 11, 1, 8, 11, 4, -1, -1, -1, -1, -1, -1, -1}, { 8, 11, 5, 5, 11, 6, 1, 2, 5, 1, 5, 6, -1, -1, -1, -1}, { 6, 4, 0, 2, 6, 0, 2, 11, 6, 5, 11, 2, 8, 11, 5, -1}, { 8, 11, 6, 1, 8, 6, 0, 8, 1, -1, -1, -1, -1, -1, -1, -1}, {11, 6, 4, 11, 4, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 7, 5, 11, 5, 9, 11, 5, 4, 9, -1, -1, -1, -1, -1, -1, -1}, { 1, 9, 11, 11, 5, 0, 7, 5, 11, 1, 11, 0, -1, -1, -1, -1}, { 7, 2, 0, 7, 0, 4, 11, 7, 4, 9, 11, 4, -1, -1, -1, -1}, { 1, 9, 11, 7, 1, 11, 2, 1, 7, -1, -1, -1, -1, -1, -1, -1}, { 3, 6, 1, 5, 4, 9, 11, 5, 9, 7, 5, 11, -1, -1, -1, -1}, { 0, 3, 6, 9, 0, 6, 9, 5, 0, 11, 5, 9, 7, 5, 11, -1}, { 9, 11, 4, 11, 7, 4, 7, 0, 4, 0, 7, 2, 3, 6, 1, -1}, { 9, 11, 7, 2, 9, 7, 9, 3, 6, 9, 2, 3, -1, -1, -1, -1}, {11, 3, 9, 9, 3, 2, 5, 4, 9, 5, 9, 2, -1, -1, -1, -1}, {11, 3, 2, 5, 11, 2, 5, 9, 11, 0, 9, 5, 1, 9, 0, -1}, { 3, 0, 4, 9, 3, 4, 11, 3, 9, -1, -1, -1, -1, -1, -1, -1}, { 3, 1, 9, 3, 9, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 5, 4, 9, 11, 5, 9, 11, 2, 5, 6, 2, 11, 1, 2, 6, -1}, {11, 6, 9, 0, 2, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, {11, 6, 1, 0, 11, 1, 11, 4, 9, 11, 0, 4, -1, -1, -1, -1}, {11, 6, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 9, 6, 10, 10, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 7, 10, 6, 10, 9, 6, 0, 1, 4, -1, -1, -1, -1, -1, -1, -1}, { 9, 6, 10, 6, 7, 10, 0, 5, 2, -1, -1, -1, -1, -1, -1, -1}, { 5, 1, 4, 2, 1, 5, 10, 9, 6, 7, 10, 6, -1, -1, -1, -1}, {10, 9, 7, 9, 3, 7, 9, 1, 3, -1, -1, -1, -1, -1, -1, -1}, { 0, 3, 4, 4, 3, 7, 10, 9, 4, 10, 4, 7, -1, -1, -1, -1}, { 2, 0, 5, 9, 1, 3, 7, 9, 3, 10, 9, 7, -1, -1, -1, -1}, { 4, 5, 2, 3, 4, 2, 3, 9, 4, 7, 9, 3, 10, 9, 7, -1}, { 2, 10, 3, 10, 6, 3, 10, 9, 6, -1, -1, -1, -1, -1, -1, -1}, { 0, 1, 4, 10, 9, 6, 3, 10, 6, 2, 10, 3, -1, -1, -1, -1}, {10, 9, 5, 6, 3, 5, 3, 0, 5, 5, 9, 6, -1, -1, -1, -1}, {10, 9, 6, 3, 10, 6, 3, 5, 10, 1, 5, 3, 4, 5, 1, -1}, { 1, 10, 9, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, {10, 9, 4, 0, 10, 4, 2, 10, 0, -1, -1, -1, -1, -1, -1, -1}, { 9, 1, 0, 5, 9, 0, 10, 9, 5, -1, -1, -1, -1, -1, -1, -1}, { 5, 10, 9, 5, 9, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 4, 6, 8, 6, 10, 8, 6, 7, 10, -1, -1, -1, -1, -1, -1, -1}, { 8, 0, 1, 1, 7, 10, 6, 7, 1, 8, 1, 10, -1, -1, -1, -1}, { 5, 2, 0, 6, 7, 10, 8, 6, 10, 4, 6, 8, -1, -1, -1, -1}, { 6, 7, 10, 8, 6, 10, 8, 1, 6, 5, 1, 8, 2, 1, 5, -1}, { 3, 7, 10, 3, 10, 8, 1, 3, 8, 4, 1, 8, -1, -1, -1, -1}, { 0, 3, 7, 10, 0, 7, 8, 0, 10, -1, -1, -1, -1, -1, -1, -1}, { 4, 1, 8, 1, 3, 8, 3, 10, 8, 10, 3, 7, 2, 0, 5, -1}, { 8, 5, 2, 3, 8, 2, 8, 7, 10, 8, 3, 7, -1, -1, -1, -1}, { 2, 10, 8, 3, 2, 8, 6, 3, 8, 4, 6, 8, -1, -1, -1, -1}, { 8, 0, 1, 6, 8, 1, 6, 10, 8, 3, 10, 6, 2, 10, 3, -1}, { 3, 0, 5, 10, 3, 5, 10, 6, 3, 8, 6, 10, 4, 6, 8, -1}, { 5, 10, 8, 6, 3, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 2, 10, 8, 4, 2, 8, 1, 2, 4, -1, -1, -1, -1, -1, -1, -1}, {10, 8, 0, 10, 0, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 1, 0, 5, 10, 1, 5, 1, 8, 4, 1, 10, 8, -1, -1, -1, -1}, { 5, 10, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 6, 7, 9, 7, 8, 9, 7, 5, 8, -1, -1, -1, -1, -1, -1, -1}, { 1, 4, 0, 7, 5, 8, 9, 7, 8, 6, 7, 9, -1, -1, -1, -1}, { 6, 7, 9, 9, 7, 2, 0, 8, 9, 0, 9, 2, -1, -1, -1, -1}, { 2, 1, 4, 8, 2, 4, 8, 7, 2, 9, 7, 8, 6, 7, 9, -1}, { 7, 5, 8, 8, 1, 3, 9, 1, 8, 7, 8, 3, -1, -1, -1, -1}, { 7, 5, 8, 9, 7, 8, 9, 3, 7, 4, 3, 9, 0, 3, 4, -1}, { 9, 1, 3, 7, 9, 3, 7, 8, 9, 2, 8, 7, 0, 8, 2, -1}, { 8, 9, 4, 3, 7, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 3, 2, 6, 6, 2, 9, 2, 5, 9, 5, 8, 9, -1, -1, -1, -1}, { 6, 3, 9, 3, 2, 9, 2, 8, 9, 8, 2, 5, 0, 1, 4, -1}, { 0, 8, 9, 6, 0, 9, 3, 0, 6, -1, -1, -1, -1, -1, -1, -1}, { 8, 9, 6, 3, 8, 6, 8, 1, 4, 8, 3, 1, -1, -1, -1, -1}, { 1, 2, 5, 8, 1, 5, 9, 1, 8, -1, -1, -1, -1, -1, -1, -1}, { 9, 4, 0, 2, 9, 0, 9, 5, 8, 9, 2, 5, -1, -1, -1, -1}, { 1, 0, 8, 1, 8, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 8, 9, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 6, 5, 4, 7, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 7, 5, 0, 1, 7, 0, 6, 7, 1, -1, -1, -1, -1, -1, -1, -1}, { 6, 7, 2, 0, 6, 2, 4, 6, 0, -1, -1, -1, -1, -1, -1, -1}, { 1, 6, 7, 1, 7, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 5, 4, 1, 3, 5, 1, 7, 5, 3, -1, -1, -1, -1, -1, -1, -1}, { 5, 0, 3, 5, 3, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 4, 1, 3, 7, 4, 3, 4, 2, 0, 4, 7, 2, -1, -1, -1, -1}, { 7, 2, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 4, 6, 3, 2, 4, 3, 5, 4, 2, -1, -1, -1, -1, -1, -1, -1}, { 6, 3, 2, 5, 6, 2, 6, 0, 1, 6, 5, 0, -1, -1, -1, -1}, { 0, 4, 6, 0, 6, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 3, 1, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 2, 5, 4, 2, 4, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 2, 5, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, { 1, 0, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}, {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1} };

/Users/scm/git/github/teem/src/seek/test/tiso.c

/Users/scm/git/github/teem/src/seek/test/trv.c

/Users/scm/git/github/teem/src/seek/textract.c

1 /* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2011, 2010, 2009, 2008 Thomas Schultz This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /* This file collects functions that implement extraction of crease * surfaces as proposed in Schultz / Theisel / Seidel, "Crease * Surfaces: From Theory to Extraction and Application to Diffusion * Tensor MRI", IEEE TVCG 16( 1 ):109-119, 2010 */ #include "seek.h" #include "privateSeek.h" /* private helper routines for the T-based extraction */ /* Converts a Hessian into the transformed tensor T ( cf. paper ) * * T is a 9-vector representing the output * evals is a 3-vector ( eigenvalues of the Hessian ) * evecs is a 9-vector ( eigenvectors of the Hessian ) * evalDiffThresh is the threshold parameter theta ( cf. Eq. ( 4 ) in paper ) * ridge is non-zero if we are looking for a ridge ( zero for valley ) */ void 41 _seekHess2T( double *T, const double *evals, const double *evecs, const double evalDiffThresh, const char ridge ) { double lambdas[3]={0.0, 0.0, 0.0}; double tmpMat[9], diag[9], evecsT[9]; if ( ridge ) { double diff = evals[1]-evals[2]; lambdas[0]=lambdas[1]=1.0; if ( diff<evalDiffThresh ) lambdas[2]=( 1.0-diff/evalDiffThresh )*( 1.0-diff/evalDiffThresh ); } else { double diff = evals[0]-evals[1]; lambdas[1]=lambdas[2]=1.0; if ( diff<evalDiffThresh ) lambdas[0]=( 1.0-diff/evalDiffThresh )*( 1.0-diff/evalDiffThresh ); } ELL_3M_ZERO_SET( diag ); ELL_3M_DIAG_SET( diag, lambdas[0], lambdas[1], lambdas[2] ); ELL_3M_TRANSPOSE( evecsT, evecs ); ELL_3M_MUL( tmpMat, diag, evecs ); ELL_3M_MUL( T, evecsT, tmpMat ); } /* Converts a Hessian derivative into a derivative of the transformed * tensor field T * * Tder is a 9-vector representing the output * hessder is a 9-vector ( Hessian derivative ) * evals is a 3-vector ( eigenvalues of the Hessian value ) * evecs is a 9-vector ( eigenvectors of the Hessian value ) * evalDiffThresh is the threshold parameter theta ( cf. Eq. ( 4 ) in the paper ) * ridge is non-zero if we are looking for a ridge ( zero for valley ) */ void 74 _seekHessder2Tder( double *Tder, const double *hessder, const double *evals, const double *evecs, const double evalDiffThresh, const char ridge ) { double evecTrans[9]; double hessderE[9]; /* Hessian derivative in eigenframe */ double tmp[9]; ELL_3M_TRANSPOSE( evecTrans, evecs ); ell_3m_mul_d( tmp, hessder, evecTrans ); ell_3m_mul_d( hessderE, evecs, tmp ); if ( ridge ) { double diff=evals[1]-evals[2]; double l3; double l3der; if ( diff<evalDiffThresh ) l3=( 1.0-diff/evalDiffThresh )*( 1.0-diff/evalDiffThresh ); else l3=0.0; hessderE[2]*=( 1.0-l3 )/( evals[0]-evals[2] ); hessderE[6]=hessderE[2]; hessderE[5]*=( 1.0-l3 )/( evals[1]-evals[2] ); hessderE[7]=hessderE[5]; if ( diff<evalDiffThresh ) l3der = 2/evalDiffThresh*( 1-diff/evalDiffThresh )* ( hessderE[8]-hessderE[4] ); else l3der=0; hessderE[8]=l3der; hessderE[0]=hessderE[1]=hessderE[3]=hessderE[4]=0.0; } else { double diff=evals[0]-evals[1]; double l1; double l1der; if ( diff<evalDiffThresh ) l1=( 1.0-diff/evalDiffThresh )*( 1.0-diff/evalDiffThresh ); else l1=0.0; hessderE[1]*=( l1-1.0 )/( evals[0]-evals[1] ); hessderE[3]=hessderE[1]; hessderE[2]*=( l1-1.0 )/( evals[0]-evals[2] ); hessderE[6]=hessderE[2]; if ( diff<evalDiffThresh ) l1der = 2/evalDiffThresh*( 1-diff/evalDiffThresh )* ( hessderE[4]-hessderE[0] ); else l1der = 0; hessderE[0]=l1der; hessderE[4]=hessderE[5]=hessderE[7]=hessderE[8]=0.0; } ell_3m_mul_d( tmp, hessderE, evecs ); ell_3m_mul_d( Tder, evecTrans, tmp ); } static int 129 findFeatureIntersection( double *results, double *Tleft, double *hessleft, double *gleft, double *Tright, double *hessright, double *gright, double idxleft, double idxright, char ridge, const double evalDiffThresh, const double dotThresh ) { double Tdp = ELL_3V_DOT( Tleft, Tright ) + ELL_3V_DOT( Tleft+3, Tright+3 ) + ELL_3V_DOT( Tleft+6, Tright+6 ); double denom_l = sqrt( ELL_3V_DOT( Tleft, Tleft ) + ELL_3V_DOT( Tleft+3, Tleft+3 ) + ELL_3V_DOT( Tleft+6, Tleft+6 ) ), denom_r = sqrt( ELL_3V_DOT( Tright, Tright ) + ELL_3V_DOT( Tright+3, Tright+3 ) + ELL_3V_DOT( Tright+6, Tright+6 ) ); if ( Tdp/( denom_l*denom_r )<dotThresh && idxright-idxleft>0.24 ) { /* do a recursive step */ double idxcenter = 0.5*( idxleft+idxright ); /* simply interpolate Hessian linearly */ double hessnew[9]; double evals[3], evecs[9]; double Tnew[9], gradnew[3]; int retval; ELL_3M_LERP( hessnew, 0.5, hessleft, hessright ); ell_3m_eigensolve_d( evals, evecs, hessnew, AIR_TRUE ); _seekHess2T( Tnew, evals, evecs, evalDiffThresh, ridge ); ELL_3V_LERP( gradnew, 0.5, gleft, gright ); retval = findFeatureIntersection( results, Tleft, hessleft, gleft, Tnew, hessnew, gradnew, idxleft, idxcenter, ridge, evalDiffThresh, dotThresh ); retval += findFeatureIntersection( results+retval, Tnew, hessnew, gradnew, Tright, hessright, gright, idxcenter, idxright, ridge, evalDiffThresh, dotThresh ); return retval; } else { double d1[3], d4[3]; ell_3mv_mul_d( d1, Tleft, gleft ); ELL_3V_SUB( d1, d1, gleft ); ell_3mv_mul_d( d4, Tright, gright ); ELL_3V_SUB( d4, d4, gright ); if ( ELL_3V_DOT( d1, d4 )<0 ) { /* mark edge as crossed */ /* find assumed intersection point */ double diff[3], dlen, alpha; ELL_3V_SUB( diff, d4, d1 ); dlen=ELL_3V_LEN( diff ); if ( dlen>1e-5 ) { double ap=-ELL_3V_DOT( d1, diff )/dlen; alpha = ap/dlen; } else alpha = 0.5; *results = ( 1-alpha )*idxleft+alpha*idxright; return 1; } } return 0; } /* Assuming ( simplistic ) linearly interpolated Hessians and gradients, * computes the analytical normal of the crease surface. * The result is _not_ normalized. */ static void 196 computeGradientLin( double *result, double *T, double *g, double *Txm, double *gxm, double *Txp, double *gxp, double *Tym, double *gym, double *Typ, double *gyp, double *Tzm, double *gzm, double *Tzp, double *gzp ) { double Tder[9]; double gder[3]; double tmp[3], tmp1[3], tmp2[3]; double derxv[3], deryv[3], derzv[3]; ELL_3M_SUB( Tder, Txp, Txm ); ELL_3V_SUB( gder, gxp, gxm ); ell_3mv_mul_d( tmp, T, gder ); ELL_3V_SUB( tmp, tmp, gder ); ell_3mv_mul_d( derxv, Tder, g ); ELL_3V_ADD2( derxv, derxv, tmp ); ELL_3M_SUB( Tder, Typ, Tym ); ELL_3V_SUB( gder, gyp, gym ); ell_3mv_mul_d( tmp, T, gder ); ELL_3V_SUB( tmp, tmp, gder ); ell_3mv_mul_d( deryv, Tder, g ); ELL_3V_ADD2( deryv, deryv, tmp ); ELL_3M_SUB( Tder, Tzp, Tzm ); ELL_3V_SUB( gder, gzp, gzm ); ell_3mv_mul_d( tmp, T, gder ); ELL_3V_SUB( tmp, tmp, gder ); ell_3mv_mul_d( derzv, Tder, g ); ELL_3V_ADD2( derzv, derzv, tmp ); /* accumulate a gradient */ tmp1[0]=derxv[0]; tmp1[1]=deryv[0]; tmp1[2]=derzv[0]; tmp2[0]=derxv[1]; tmp2[1]=deryv[1]; tmp2[2]=derzv[1]; if ( ELL_3V_DOT( tmp1, tmp2 )<0 ) ELL_3V_SCALE( tmp2, -1.0, tmp2 ); ELL_3V_ADD2( tmp1, tmp1, tmp2 ); tmp2[0]=derxv[2]; tmp2[1]=deryv[2]; tmp2[2]=derzv[2]; if ( ELL_3V_DOT( tmp1, tmp2 )<0 ) ELL_3V_SCALE( tmp2, -1.0, tmp2 ); ELL_3V_ADD2( result, tmp1, tmp2 ); } /* Given a unique edge ID and an intersection point given by some value * alpha \in [0, 1], compute the crease surface normal at that point */ static void 240 computeEdgeGradient( seekContext *sctx, baggage *bag, double *res, unsigned int xi, unsigned int yi, char edgeid, double alpha ) { double Txm[9], Txp[9], Tym[9], Typ[9], Tzm[9], Tzp[9], T[9], gxm[3], gxp[3], gym[3], gyp[3], gzm[3], gzp[3], g[3]; unsigned int sx = AIR_CAST( unsigned int, sctx->sx ); unsigned int sy = AIR_CAST( unsigned int, sctx->sy ); unsigned int sz = AIR_CAST( unsigned int, sctx->sz ); unsigned int si = xi + sx*yi; unsigned int six = xi + 1 + sx*yi, siX = xi - 1 + sx*yi; unsigned int siy = xi + sx*( yi+1 ), siY = xi + sx*( yi-1 ); unsigned int sixy = xi + 1 + sx*( yi+1 ), sixY = xi + 1 + sx*( yi-1 ), siXy = xi - 1 + sx*( yi+1 ); /* many special cases needed to fill Txm, gxm, etc. :-( */ switch ( edgeid ) { case 0: ELL_3M_LERP( T, alpha, sctx->t + 9*( 0+2*si ), sctx->t + 9*( 0+2*six ) ); ELL_3V_LERP( g, alpha, sctx->grad + 3*( 0+2*si ), sctx->grad + 3*( 0+2*six ) ); ELL_3M_LERP( Tzp, alpha, sctx->t + 9*( 1+2*si ), sctx->t + 9*( 1+2*six ) ); ELL_3V_LERP( gzp, alpha, sctx->grad + 3*( 1+2*si ), sctx->grad + 3*( 1+2*six ) ); if ( bag->zi==0 ) { ELL_3M_COPY( Tzm, T ); ELL_3V_COPY( gzm, g ); } else { ELL_3M_LERP( Tzm, alpha, sctx->tcontext + 9*( 0+2*si ), sctx->tcontext + 9*( 0+2*six ) ); ELL_3V_LERP( gzm, alpha, sctx->gradcontext + 3*( 0+2*si ), sctx->gradcontext + 3*( 0+2*six ) ); ELL_3M_SCALE( Tzm, 0.5, Tzm ); ELL_3M_SCALE( Tzp, 0.5, Tzp ); ELL_3V_SCALE( gzm, 0.5, gzm ); ELL_3V_SCALE( gzp, 0.5, gzp ); } if ( yi==0 ) { ELL_3M_COPY( Tym, T ); ELL_3V_COPY( gym, g ); } else { ELL_3M_LERP( Tym, alpha, sctx->t + 9*( 0+2*siY ), sctx->t + 9*( 0+2*sixY ) ); ELL_3V_LERP( gym, alpha, sctx->grad + 3*( 0+2*siY ), sctx->grad + 3*( 0+2*sixY ) ); } if ( yi==sy-1 ) { ELL_3M_COPY( Typ, T ); ELL_3V_COPY( gyp, g ); } else { ELL_3M_LERP( Typ, alpha, sctx->t + 9*( 0+2*siy ), sctx->t + 9*( 0+2*sixy ) ); ELL_3V_LERP( gyp, alpha, sctx->grad + 3*( 0+2*siy ), sctx->grad + 3*( 0+2*sixy ) ); } if ( yi!=0 && yi!=sy-1 ) { ELL_3M_SCALE( Tym, 0.5, Tym ); ELL_3M_SCALE( Typ, 0.5, Typ ); ELL_3V_SCALE( gym, 0.5, gym ); ELL_3V_SCALE( gyp, 0.5, gyp ); } computeGradientLin( res, T, g, sctx->t + 9*( 0+2*si ), sctx->grad + 3*( 0+2*si ), sctx->t + 9*( 0+2*six ), sctx->grad + 3*( 0+2*six ), Tym, gym, Typ, gyp, Tzm, gzm, Tzp, gzp ); break; case 1: ELL_3M_LERP( T, alpha, sctx->t + 9*( 0+2*si ), sctx->t + 9*( 0+2*siy ) ); ELL_3V_LERP( g, alpha, sctx->grad + 3*( 0+2*si ), sctx->grad + 3*( 0+2*siy ) ); ELL_3M_LERP( Tzp, alpha, sctx->t + 9*( 1+2*si ), sctx->t + 9*( 1+2*siy ) ); ELL_3V_LERP( gzp, alpha, sctx->grad + 3*( 1+2*si ), sctx->grad + 3*( 1+2*siy ) ); if ( bag->zi==0 ) { ELL_3M_COPY( Tzm, T ); ELL_3V_COPY( gzm, g ); } else { ELL_3M_LERP( Tzm, alpha, sctx->tcontext + 9*( 0+2*si ), sctx->tcontext + 9*( 0+2*siy ) ); ELL_3V_LERP( gzm, alpha, sctx->gradcontext + 3*( 0+2*si ), sctx->gradcontext + 3*( 0+2*siy ) ); ELL_3M_SCALE( Tzm, 0.5, Tzm ); ELL_3M_SCALE( Tzp, 0.5, Tzp ); ELL_3V_SCALE( gzm, 0.5, gzm ); ELL_3V_SCALE( gzp, 0.5, gzp ); } if ( xi==0 ) { ELL_3M_COPY( Txm, T ); ELL_3V_COPY( gxm, g ); } else { ELL_3M_LERP( Txm, alpha, sctx->t + 9*( 0+2*siX ), sctx->t + 9*( 0+2*siXy ) ); ELL_3V_LERP( gxm, alpha, sctx->grad + 3*( 0+2*siX ), sctx->grad + 3*( 0+2*siXy ) ); } if ( xi==sx-1 ) { ELL_3M_COPY( Txp, T ); ELL_3V_COPY( gxm, g ); } else { ELL_3M_LERP( Txp, alpha, sctx->t + 9*( 0+2*six ), sctx->t + 9*( 0+2*sixy ) ); ELL_3V_LERP( gxp, alpha, sctx->grad + 3*( 0+2*six ), sctx->grad + 3*( 0+2*sixy ) ); } if ( xi!=0 && xi!=sx-1 ) { ELL_3M_SCALE( Txm, 0.5, Txm ); ELL_3M_SCALE( Txp, 0.5, Txp ); ELL_3V_SCALE( gxm, 0.5, gxm ); ELL_3V_SCALE( gxp, 0.5, gxp ); } computeGradientLin( res, T, g, Txm, gxm, Txp, gxp, sctx->t + 9*( 0+2*si ), sctx->grad + 3*( 0+2*si ), sctx->t + 9*( 0+2*siy ), sctx->grad + 3*( 0+2*siy ), T, g, Tzp, gzp ); break; case 2: ELL_3M_LERP( T, alpha, sctx->t + 9*( 0+2*si ), sctx->t + 9*( 1+2*si ) ); ELL_3V_LERP( g, alpha, sctx->grad + 3*( 0+2*si ), sctx->grad + 3*( 1+2*si ) ); if ( xi==0 ) { ELL_3M_COPY( Txm, T ); ELL_3V_COPY( gxm, g ); } else { ELL_3M_LERP( Txm, alpha, sctx->t + 9*( 0+2*siX ), sctx->t + 9*( 1+2*siX ) ); ELL_3V_LERP( gxm, alpha, sctx->grad + 3*( 0+2*siX ), sctx->grad + 3*( 1+2*siX ) ); } if ( xi==sx-1 ) { ELL_3M_COPY( Txp, T ); ELL_3V_COPY( gxp, g ); } else { ELL_3M_LERP( Txp, alpha, sctx->t + 9*( 0+2*six ), sctx->t + 9*( 1+2*six ) ); ELL_3V_LERP( gxp, alpha, sctx->grad + 3*( 0+2*six ), sctx->grad + 3*( 1+2*six ) ); } if ( xi!=0 && xi!=sx-1 ) { ELL_3M_SCALE( Txm, 0.5, Txm ); ELL_3M_SCALE( Txp, 0.5, Txp ); ELL_3V_SCALE( gxm, 0.5, gxm ); ELL_3V_SCALE( gxp, 0.5, gxp ); } if ( yi==0 ) { ELL_3M_COPY( Tym, T ); ELL_3V_COPY( gym, g ); } else { ELL_3M_LERP( Tym, alpha, sctx->t + 9*( 0+2*siY ), sctx->t + 9*( 1+2*siY ) ); ELL_3V_LERP( gym, alpha, sctx->grad + 3*( 0+2*siY ), sctx->grad + 3*( 1+2*siY ) ); } if ( yi==sy-1 ) { ELL_3M_COPY( Typ, T ); ELL_3V_COPY( gyp, g ); } else { ELL_3M_LERP( Typ, alpha, sctx->t + 9*( 0+2*siy ), sctx->t + 9*( 1+2*siy ) ); ELL_3V_LERP( gyp, alpha, sctx->grad + 3*( 0+2*siy ), sctx->grad + 3*( 1+2*siy ) ); } if ( yi!=0 && yi!=sy-1 ) { ELL_3M_SCALE( Tym, 0.5, Tym ); ELL_3M_SCALE( Typ, 0.5, Typ ); ELL_3V_SCALE( gym, 0.5, gym ); ELL_3V_SCALE( gyp, 0.5, gyp ); } if ( bag->zi>0 && bag->zi<sz-2 ) { ELL_3M_LERP( Tzm, alpha, sctx->tcontext + 9*( 0+2*si ), sctx->t + 9*( 0+2*si ) ); ELL_3V_LERP( gzm, alpha, sctx->gradcontext + 3*( 0+2*si ), sctx->grad + 3*( 0+2*si ) ); ELL_3M_LERP( Tzp, alpha, sctx->t + 9*( 1+2*si ), sctx->tcontext + 9*( 1+2*si ) ); ELL_3V_LERP( gzp, alpha, sctx->grad + 3*( 1+2*si ), sctx->gradcontext + 3*( 1+2*si ) ); ELL_3M_SCALE( Tzm, 0.5, Tzm ); ELL_3M_SCALE( Tzp, 0.5, Tzp ); ELL_3V_SCALE( gzm, 0.5, gzm ); ELL_3V_SCALE( gzp, 0.5, gzp ); } else { ELL_3M_COPY( Tzm, sctx->t + 9*( 0+2*si ) ); ELL_3V_COPY( gzm, sctx->grad + 3*( 0+2*si ) ); ELL_3M_COPY( Tzp, sctx->t + 9*( 1+2*si ) ); ELL_3V_COPY( gzp, sctx->grad + 3*( 1+2*si ) ); } computeGradientLin( res, T, g, Txm, gxm, Txp, gxp, Tym, gym, Typ, gyp, Tzm, gzm, Tzp, gzp ); break; case 3: ELL_3M_LERP( T, alpha, sctx->t + 9*( 1+2*si ), sctx->t + 9*( 1+2*six ) ); ELL_3V_LERP( g, alpha, sctx->grad + 3*( 1+2*si ), sctx->grad + 3*( 1+2*six ) ); ELL_3M_LERP( Tzm, alpha, sctx->t + 9*( 0+2*si ), sctx->t + 9*( 0+2*six ) ); ELL_3V_LERP( gzm, alpha, sctx->grad + 3*( 0+2*si ), sctx->grad + 3*( 0+2*six ) ); if ( bag->zi==sz-2 ) { ELL_3M_COPY( Tzp, T ); ELL_3V_COPY( gzp, g ); } else { ELL_3M_LERP( Tzp, alpha, sctx->tcontext + 9*( 1+2*si ), sctx->tcontext + 9*( 1+2*six ) ); ELL_3V_LERP( gzp, alpha, sctx->gradcontext + 3*( 1+2*si ), sctx->gradcontext + 3*( 1+2*six ) ); ELL_3M_SCALE( Tzm, 0.5, Tzm ); ELL_3M_SCALE( Tzp, 0.5, Tzp ); ELL_3V_SCALE( gzm, 0.5, gzm ); ELL_3V_SCALE( gzp, 0.5, gzp ); } if ( xi>0 && xi<sx-2 ) { unsigned int sixx = xi + 2 + sx*yi; ELL_3M_LERP( Txm, alpha, sctx->t + 9*( 1+2*siX ), sctx->t + 9*( 1+2*si ) ); ELL_3V_LERP( gxm, alpha, sctx->grad + 3*( 1+2*siX ), sctx->grad + 3*( 1+2*si ) ); ELL_3M_LERP( Txp, alpha, sctx->t + 9*( 1+2*six ), sctx->t + 9*( 1+2*sixx ) ); ELL_3V_LERP( gxp, alpha, sctx->grad + 3*( 1+2*six ), sctx->grad + 3*( 1+2*sixx ) ); ELL_3M_SCALE( Txm, 0.5, Txm ); ELL_3M_SCALE( Txp, 0.5, Txp ); ELL_3V_SCALE( gxm, 0.5, gxm ); ELL_3V_SCALE( gxp, 0.5, gxp ); } else { ELL_3M_COPY( Txm, sctx->t + 9*( 1+2*si ) ); ELL_3V_COPY( gxm, sctx->grad + 3*( 1+2*si ) ); ELL_3M_COPY( Txp, sctx->t + 9*( 1+2*six ) ); ELL_3V_COPY( gxp, sctx->grad + 3*( 1+2*six ) ); } if ( yi==0 ) { ELL_3M_COPY( Tym, T ); ELL_3V_COPY( gym, g ); } else { ELL_3M_LERP( Tym, alpha, sctx->t + 9*( 1+2*siY ), sctx->t + 9*( 1+2*sixY ) ); ELL_3V_LERP( gym, alpha, sctx->grad + 3*( 1+2*siY ), sctx->grad + 3*( 1+2*sixY ) ); } if ( yi==sy-1 ) { ELL_3M_COPY( Typ, T ); ELL_3V_COPY( gyp, g ); } else { ELL_3M_LERP( Typ, alpha, sctx->t + 9*( 1+2*siy ), sctx->t + 9*( 1+2*sixy ) ); ELL_3V_LERP( gyp, alpha, sctx->grad + 3*( 1+2*siy ), sctx->grad + 3*( 1+2*sixy ) ); } if ( yi!=0 && yi!=sy-1 ) { ELL_3M_SCALE( Tym, 0.5, Tym ); ELL_3M_SCALE( Typ, 0.5, Typ ); ELL_3V_SCALE( gym, 0.5, gym ); ELL_3V_SCALE( gyp, 0.5, gyp ); } computeGradientLin( res, T, g, Txm, gxm, Txp, gxp, Tym, gym, Typ, gyp, Tzm, gzm, Tzp, gzp ); break; case 4: ELL_3M_LERP( T, alpha, sctx->t + 9*( 1+2*si ), sctx->t + 9*( 1+2*siy ) ); ELL_3V_LERP( g, alpha, sctx->grad + 3*( 1+2*si ), sctx->grad + 3*( 1+2*siy ) ); ELL_3M_LERP( Tzm, alpha, sctx->t + 9*( 0+2*si ), sctx->t + 9*( 0+2*siy ) ); ELL_3V_LERP( gzm, alpha, sctx->grad + 3*( 0+2*si ), sctx->grad + 3*( 0+2*siy ) ); if ( bag->zi==sz-2 ) { ELL_3M_COPY( Tzp, T ); ELL_3V_COPY( gzp, g ); } else { ELL_3M_LERP( Tzp, alpha, sctx->tcontext + 9*( 1+2*si ), sctx->tcontext + 9*( 1+2*siy ) ); ELL_3V_LERP( gzp, alpha, sctx->gradcontext + 3*( 1+2*si ), sctx->gradcontext + 3*( 1+2*siy ) ); ELL_3M_SCALE( Tzm, 0.5, Tzm ); ELL_3M_SCALE( Tzp, 0.5, Tzp ); ELL_3V_SCALE( gzm, 0.5, gzm ); ELL_3V_SCALE( gzp, 0.5, gzp ); } if ( xi==0 ) { ELL_3M_COPY( Txm, T ); ELL_3V_COPY( gxm, g ); } else { ELL_3M_LERP( Txm, alpha, sctx->t + 9*( 1+2*siX ), sctx->t + 9*( 1+2*siXy ) ); ELL_3V_LERP( gxm, alpha, sctx->grad + 3*( 1+2*siX ), sctx->grad + 3*( 1+2*siXy ) ); } if ( xi==sx-1 ) { ELL_3M_COPY( Txp, T ); ELL_3V_COPY( gxp, g ); } else { ELL_3M_LERP( Txp, alpha, sctx->t + 9*( 1+2*six ), sctx->t + 9*( 1+2*sixy ) ); ELL_3V_LERP( gxp, alpha, sctx->grad + 3*( 1+2*six ), sctx->grad + 3*( 1+2*sixy ) ); } if ( xi!=0 && xi!=sx-1 ) { ELL_3M_SCALE( Txm, 0.5, Txm ); ELL_3M_SCALE( Txp, 0.5, Txp ); ELL_3V_SCALE( gxm, 0.5, gxm ); ELL_3V_SCALE( gxp, 0.5, gxp ); } if ( yi>0 && yi<sy-2 ) { unsigned int siyy = xi + sx*( yi+2 ); ELL_3M_LERP( Tym, alpha, sctx->t + 9*( 1+2*siY ), sctx->t + 9*( 1+2*si ) ); ELL_3V_LERP( gym, alpha, sctx->grad + 3*( 1+2*siY ), sctx->grad + 3*( 1+2*si ) ); ELL_3M_LERP( Typ, alpha, sctx->t + 9*( 1+2*siy ), sctx->t + 9*( 1+2*siyy ) ); ELL_3V_LERP( gyp, alpha, sctx->grad + 3*( 1+2*siy ), sctx->grad + 3*( 1+2*siyy ) ); ELL_3M_SCALE( Tym, 0.5, Tym ); ELL_3M_SCALE( Typ, 0.5, Typ ); ELL_3V_SCALE( gym, 0.5, gym ); ELL_3V_SCALE( gyp, 0.5, gyp ); } else { ELL_3M_COPY( Tym, sctx->t + 9*( 1+2*si ) ); ELL_3V_COPY( gym, sctx->grad + 3*( 1+2*si ) ); ELL_3M_COPY( Typ, sctx->t + 9*( 1+2*six ) ); ELL_3V_COPY( gyp, sctx->grad + 3*( 1+2*six ) ); } computeGradientLin( res, T, g, Txm, gxm, Txp, gxp, Tym, gym, Typ, gyp, Tzm, gzm, Tzp, gzp ); break; } } /* Given a unique face ID and coordinates, compute the crease surface * normal at the specified degenerate point */ static void 510 computeFaceGradient( seekContext *sctx, double *res, unsigned int xi, unsigned int yi, char faceid, double *coords ) { double T[9], Txm[9], Txp[9], Tym[9], Typ[9], Tzm[9], Tzp[9], g[3], gxm[3], gxp[3], gym[3], gyp[3], gzm[3], gzp[3]; unsigned int sx = AIR_CAST( unsigned int, sctx->sx ); unsigned int sy = AIR_CAST( unsigned int, sctx->sy ); unsigned int si = xi + sx*yi; unsigned int six = xi + 1 + sx*yi, siX = xi - 1 + sx*yi; unsigned int siy = xi + sx*( yi+1 ), siY = xi + sx*( yi-1 ); unsigned int sixy = xi + 1 + sx*( yi+1 ), sixY = xi + 1 + sx*( yi-1 ), siXy = xi - 1 + sx*( yi+1 ); /* Again, lots of special cases to fill Txm, gxm, etc. */ switch ( faceid ) { case 0: /* bilinearly interpolate Tzp/gzp first */ ELL_3M_LERP( Txm, coords[1], sctx->t + 9*( 1+2*si ), sctx->t + 9*( 1+2*siy ) ); ELL_3V_LERP( gxm, coords[1], sctx->grad + 3*( 1+2*si ), sctx->grad + 3*( 1+2*siy ) ); ELL_3M_LERP( Txp, coords[1], sctx->t + 9*( 1+2*six ), sctx->t + 9*( 1+2*sixy ) ); ELL_3V_LERP( gxp, coords[1], sctx->grad + 3*( 1+2*six ), sctx->grad + 3*( 1+2*sixy ) ); ELL_3M_LERP( Tzp, coords[0], Txm, Txp ); ELL_3V_LERP( gzp, coords[0], gxm, gxp ); /* now, compute all required points on the bottom face */ ELL_3M_LERP( Txm, coords[1], sctx->t + 9*( 0+2*si ), sctx->t + 9*( 0+2*siy ) ); ELL_3V_LERP( gxm, coords[1], sctx->grad + 3*( 0+2*si ), sctx->grad + 3*( 0+2*siy ) ); ELL_3M_LERP( Txp, coords[1], sctx->t + 9*( 0+2*six ), sctx->t + 9*( 0+2*sixy ) ); ELL_3V_LERP( gxp, coords[1], sctx->grad + 3*( 0+2*six ), sctx->grad + 3*( 0+2*sixy ) ); ELL_3M_LERP( Tym, coords[0], sctx->t + 9*( 0+2*si ), sctx->t + 9*( 0+2*six ) ); ELL_3V_LERP( gym, coords[0], sctx->grad + 3*( 0+2*si ), sctx->grad + 3*( 0+2*six ) ); ELL_3M_LERP( Typ, coords[0], sctx->t + 9*( 0+2*siy ), sctx->t + 9*( 0+2*sixy ) ); ELL_3V_LERP( gyp, coords[0], sctx->grad + 3*( 0+2*siy ), sctx->grad + 3*( 0+2*sixy ) ); ELL_3M_LERP( T, coords[0], Txm, Txp ); ELL_3V_LERP( g, coords[0], gxm, gxp ); computeGradientLin( sctx->facenorm+3*( faceid+4*si ), T, g, Txm, gxm, Txp, gxp, Tym, gym, Typ, gyp, T, g, Tzp, gzp ); break; case 1: /* bilinearly interpolate Typ/gyp first */ if ( yi!=sy-1 ) { ELL_3M_LERP( Txm, coords[1], sctx->t + 9*( 0+2*siy ), sctx->t + 9*( 1+2*siy ) ); ELL_3V_LERP( gxm, coords[1], sctx->grad + 3*( 0+2*siy ), sctx->grad + 3*( 1+2*siy ) ); ELL_3M_LERP( Txp, coords[1], sctx->t + 9*( 0+2*sixy ), sctx->t + 9*( 1+2*sixy ) ); ELL_3V_LERP( gxp, coords[1], sctx->grad + 3*( 0+2*sixy ), sctx->grad + 3*( 1+2*sixy ) ); ELL_3M_LERP( Typ, coords[0], Txm, Txp ); ELL_3V_LERP( gyp, coords[0], gxm, gxp ); } else { ELL_3M_LERP( Txm, coords[1], sctx->t + 9*( 0+2*siY ), sctx->t + 9*( 1+2*siY ) ); ELL_3V_LERP( gxm, coords[1], sctx->grad + 3*( 0+2*siY ), sctx->grad + 3*( 1+2*siY ) ); ELL_3M_LERP( Txp, coords[1], sctx->t + 9*( 0+2*sixY ), sctx->t + 9*( 1+2*sixY ) ); ELL_3V_LERP( gxp, coords[1], sctx->grad + 3*( 0+2*sixY ), sctx->grad + 3*( 1+2*sixY ) ); ELL_3M_LERP( Tym, coords[0], Txm, Txp ); ELL_3V_LERP( gym, coords[0], gxm, gxp ); } /* now, compute remaining points */ ELL_3M_LERP( Txm, coords[1], sctx->t + 9*( 0+2*si ), sctx->t + 9*( 1+2*si ) ); ELL_3V_LERP( gxm, coords[1], sctx->grad + 3*( 0+2*si ), sctx->grad + 3*( 1+2*si ) ); ELL_3M_LERP( Txp, coords[1], sctx->t + 9*( 0+2*six ), sctx->t + 9*( 1+2*six ) ); ELL_3V_LERP( gxp, coords[1], sctx->grad + 3*( 0+2*six ), sctx->grad + 3*( 1+2*six ) ); ELL_3M_LERP( Tzm, coords[0], sctx->t + 9*( 0+2*si ), sctx->t + 9*( 0+2*six ) ); ELL_3V_LERP( gzm, coords[0], sctx->grad + 3*( 0+2*si ), sctx->grad + 3*( 0+2*six ) ); ELL_3M_LERP( Tzp, coords[0], sctx->t + 9*( 1+2*si ), sctx->t + 9*( 1+2*six ) ); ELL_3V_LERP( gzp, coords[0], sctx->grad + 3*( 1+2*si ), sctx->grad + 3*( 1+2*six ) ); ELL_3M_LERP( T, coords[0], Txm, Txp ); ELL_3V_LERP( g, coords[0], gxm, gxp ); if ( yi!=sy-1 ) { computeGradientLin( sctx->facenorm+3*( faceid+4*si ), T, g, Txm, gxm, Txp, gxp, T, g, Typ, gyp, Tzm, gzm, Tzp, gzp ); } else { computeGradientLin( sctx->facenorm+3*( faceid+4*si ), T, g, Txm, gxm, Txp, gxp, Tym, gym, T, g, Tzm, gzm, Tzp, gzp ); } break; case 2: /* bilinearly interpolate Txp/gxp first */ if ( xi!=sx-1 ) { ELL_3M_LERP( Tym, coords[1], sctx->t + 9*( 0+2*six ), sctx->t + 9*( 1+2*six ) ); ELL_3V_LERP( gym, coords[1], sctx->grad + 3*( 0+2*six ), sctx->grad + 3*( 1+2*six ) ); ELL_3M_LERP( Typ, coords[1], sctx->t + 9*( 0+2*sixy ), sctx->t + 9*( 1+2*sixy ) ); ELL_3V_LERP( gyp, coords[1], sctx->grad + 3*( 0+2*sixy ), sctx->grad + 3*( 1+2*sixy ) ); ELL_3M_LERP( Txp, coords[0], Tym, Typ ); ELL_3V_LERP( gxp, coords[0], gym, gyp ); } else { ELL_3M_LERP( Tym, coords[1], sctx->t + 9*( 0+2*siX ), sctx->t + 9*( 1+2*siX ) ); ELL_3V_LERP( gym, coords[1], sctx->grad + 3*( 0+2*siX ), sctx->grad + 3*( 1+2*siX ) ); ELL_3M_LERP( Typ, coords[1], sctx->t + 9*( 0+2*siXy ), sctx->t + 9*( 1+2*siXy ) ); ELL_3V_LERP( gyp, coords[1], sctx->grad + 3*( 0+2*siXy ), sctx->grad + 3*( 1+2*siXy ) ); ELL_3M_LERP( Txm, coords[0], Tym, Typ ); ELL_3V_LERP( gxm, coords[0], gym, gyp ); } /* now, compute remaining points */ ELL_3M_LERP( Tym, coords[1], sctx->t + 9*( 0+2*si ), sctx->t + 9*( 1+2*si ) ); ELL_3V_LERP( gym, coords[1], sctx->grad + 3*( 0+2*si ), sctx->grad + 3*( 1+2*si ) ); ELL_3M_LERP( Typ, coords[1], sctx->t + 9*( 0+2*siy ), sctx->t + 9*( 1+2*siy ) ); ELL_3V_LERP( gyp, coords[1], sctx->grad + 3*( 0+2*siy ), sctx->grad + 3*( 1+2*siy ) ); ELL_3M_LERP( Tzm, coords[0], sctx->t + 9*( 0+2*si ), sctx->t + 9*( 0+2*siy ) ); ELL_3V_LERP( gzm, coords[0], sctx->grad + 3*( 0+2*si ), sctx->grad + 3*( 0+2*siy ) ); ELL_3M_LERP( Tzp, coords[0], sctx->t + 9*( 1+2*si ), sctx->t + 9*( 1+2*siy ) ); ELL_3V_LERP( gzp, coords[0], sctx->grad + 3*( 1+2*si ), sctx->grad + 3*( 1+2*siy ) ); ELL_3M_LERP( T, coords[0], Tym, Typ ); ELL_3V_LERP( g, coords[0], gym, gyp ); if ( xi!=sx-1 ) { computeGradientLin( sctx->facenorm+3*( faceid+4*si ), T, g, T, g, Txp, gxp, Tym, gym, Typ, gyp, Tzm, gzm, Tzp, gzp ); } else { computeGradientLin( sctx->facenorm+3*( faceid+4*si ), T, g, Txm, gxm, T, g, Tym, gym, Typ, gyp, Tzm, gzm, Tzp, gzp ); } break; case 3: /* bilinearly interpolate Tzm/gzm first */ ELL_3M_LERP( Txm, coords[1], sctx->t + 9*( 0+2*si ), sctx->t + 9*( 0+2*siy ) ); ELL_3V_LERP( gxm, coords[1], sctx->grad + 3*( 0+2*si ), sctx->grad + 3*( 0+2*siy ) ); ELL_3M_LERP( Txp, coords[1], sctx->t + 9*( 0+2*six ), sctx->t + 9*( 0+2*sixy ) ); ELL_3V_LERP( gxp, coords[1], sctx->grad + 3*( 0+2*six ), sctx->grad + 3*( 0+2*sixy ) ); ELL_3M_LERP( Tzm, coords[0], Txm, Txp ); ELL_3V_LERP( gzm, coords[0], gxm, gxp ); /* now, compute all required points on the top face */ ELL_3M_LERP( Txm, coords[1], sctx->t + 9*( 1+2*si ), sctx->t + 9*( 1+2*siy ) ); ELL_3V_LERP( gxm, coords[1], sctx->grad + 3*( 1+2*si ), sctx->grad + 3*( 1+2*siy ) ); ELL_3M_LERP( Txp, coords[1], sctx->t + 9*( 1+2*six ), sctx->t + 9*( 1+2*sixy ) ); ELL_3V_LERP( gxp, coords[1], sctx->grad + 3*( 1+2*six ), sctx->grad + 3*( 1+2*sixy ) ); ELL_3M_LERP( Tym, coords[0], sctx->t + 9*( 1+2*si ), sctx->t + 9*( 1+2*six ) ); ELL_3V_LERP( gym, coords[0], sctx->grad + 3*( 1+2*si ), sctx->grad + 3*( 1+2*six ) ); ELL_3M_LERP( Typ, coords[0], sctx->t + 9*( 1+2*siy ), sctx->t + 9*( 1+2*sixy ) ); ELL_3V_LERP( gyp, coords[0], sctx->grad + 3*( 1+2*siy ), sctx->grad + 3*( 1+2*sixy ) ); ELL_3M_LERP( T, coords[0], Txm, Txp ); ELL_3V_LERP( g, coords[0], gxm, gxp ); computeGradientLin( sctx->facenorm+3*( faceid+4*si ), T, g, Txm, gxm, Txp, gxp, Tym, gym, Typ, gyp, Tzm, gzm, T, g ); break; } ELL_3V_COPY( res, sctx->facenorm+3*( faceid+4*si ) ); } /* small helper routines: intersection tests */ /* check if a given 2D triangle is oriented clockwise ( -1 ) * or counter-clockwise ( 1 ). * returns 0 if given points are collinear */ static int 707 checkTriOrientation ( double *p1, double *p2, double *p3 ) { double test = ( ( ( p2[0]-p1[0] )*( p3[1]-p1[1] ) ) - ( ( p3[0]-p1[0] )*( p2[1]-p1[1] ) ) ); if ( test > 0 ) return 1; else if ( test < 0 ) return -1; else return 0; } /* check if two given 2D lines intersect */ static int 716 lineIntersectionTest ( double *l1p1, double *l1p2, double *l2p1, double *l2p2 ) { int or1 = checkTriOrientation( l1p1, l1p2, l2p1 ); int or2 = checkTriOrientation( l1p1, l1p2, l2p2 ); if ( or1 != or2 ) { or1 = checkTriOrientation( l2p1, l2p2, l1p1 ); or2 = checkTriOrientation( l2p1, l2p2, l1p2 ); if ( or1 != or2 ) return 1; } return 0; } /* check if two given 3D triangles intersect */ static int 730 triIntersectionTest ( double *t1v1, double *t1v2, double *t1v3, double *t2v1, double *t2v2, double *t2v3 ) { double n1[3], n2[3], d1, d2; double diff1[3], diff2[3]; double t2sd1, t2sd2, t2sd3; ELL_3V_SUB( diff1, t1v2, t1v1 ); ELL_3V_SUB( diff2, t1v3, t1v1 ); ELL_3V_CROSS( n1, diff1, diff2 ); d1=-ELL_3V_DOT( n1, t1v1 ); /* compute scaled signed distances of t2 to plane of t1 */ t2sd1 = ELL_3V_DOT( n1, t2v1 )+d1; t2sd2 = ELL_3V_DOT( n1, t2v2 )+d1; t2sd3 = ELL_3V_DOT( n1, t2v3 )+d1; if ( t2sd1==0 && t2sd2==0 && t2sd3==0 ) { /* coplanar case: handle in 2D */ double t1v12d[2], t1v22d[2], t1v32d[2], t2v12d[2], t2v22d[2], t2v32d[2]; if ( fabs( n1[0] )>=fabs( n1[1] ) && fabs( n1[0] )>=fabs( n1[2] ) ) { t1v12d[0]=t1v1[1]; t1v12d[1]=t1v1[2]; t1v22d[0]=t1v2[1]; t1v22d[1]=t1v2[2]; t1v32d[0]=t1v3[1]; t1v32d[1]=t1v3[2]; t2v12d[0]=t2v1[1]; t2v12d[1]=t2v1[2]; t2v22d[0]=t2v2[1]; t2v22d[1]=t2v2[2]; t2v32d[0]=t2v3[1]; t2v32d[1]=t2v3[2]; } else if ( fabs( n1[1] )>=fabs( n1[0] ) && fabs( n1[1] )>=fabs( n1[2] ) ) { t1v12d[0]=t1v1[0]; t1v12d[1]=t1v1[2]; t1v22d[0]=t1v2[0]; t1v22d[1]=t1v2[2]; t1v32d[0]=t1v3[0]; t1v32d[1]=t1v3[2]; t2v12d[0]=t2v1[0]; t2v12d[1]=t2v1[2]; t2v22d[0]=t2v2[0]; t2v22d[1]=t2v2[2]; t2v32d[0]=t2v3[0]; t2v32d[1]=t2v3[2]; } else { t1v12d[0]=t1v1[0]; t1v12d[1]=t1v1[1]; t1v22d[0]=t1v2[0]; t1v22d[1]=t1v2[1]; t1v32d[0]=t1v3[0]; t1v32d[1]=t1v3[1]; t2v12d[0]=t2v1[0]; t2v12d[1]=t2v1[1]; t2v22d[0]=t2v2[0]; t2v22d[1]=t2v2[1]; t2v32d[0]=t2v3[0]; t2v32d[1]=t2v3[1]; } /* we may assume that none of the triangles is fully contained * within the other. Thus, it suffices to do a lot of 2D line-line * intersections */ if ( lineIntersectionTest( t1v12d, t1v22d, t2v12d, t2v22d ) || lineIntersectionTest( t1v22d, t1v32d, t2v12d, t2v22d ) || lineIntersectionTest( t1v32d, t1v12d, t2v12d, t2v22d ) || lineIntersectionTest( t1v12d, t1v22d, t2v22d, t2v32d ) || lineIntersectionTest( t1v22d, t1v32d, t2v22d, t2v32d ) || lineIntersectionTest( t1v32d, t1v12d, t2v22d, t2v32d ) || lineIntersectionTest( t1v12d, t1v22d, t2v32d, t2v12d ) || lineIntersectionTest( t1v22d, t1v32d, t2v32d, t2v12d ) || lineIntersectionTest( t1v32d, t1v12d, t2v32d, t2v12d ) ) return 1; return 0; } else { /* pointers to the vertices on the same side / opposite side of plane */ double *t2s11, *t2s12, *t2s2, t2s11sd, t2s12sd, t2s2sd; double t1sd1, t1sd2, t1sd3; double *t1s11, *t1s12, *t1s2, t1s11sd, t1s12sd, t1s2sd; double t1p11, t1p12, t1p2, t2p11, t2p12, t2p2; double D[3]; /* direction vector of line */ double t1t1, t1t2, t2t1, t2t2; if ( t2sd1*t2sd2>=0 && t2sd1*t2sd3<=0 ) { t2s11=t2v1; t2s12=t2v2; t2s2=t2v3; t2s11sd=t2sd1; t2s12sd=t2sd2; t2s2sd=t2sd3; } else if ( t2sd1*t2sd3>=0 && t2sd1*t2sd2<=0 ) { t2s11=t2v1; t2s12=t2v3; t2s2=t2v2; t2s11sd=t2sd1; t2s12sd=t2sd3; t2s2sd=t2sd2; } else if ( t2sd2*t2sd3>=0 && t2sd1*t2sd2<=0 ) { t2s11=t2v2; t2s12=t2v3; t2s2=t2v1; t2s11sd=t2sd2; t2s12sd=t2sd3; t2s2sd=t2sd1; } else return 0; /* all on the same side; no intersection */ /* same game for triangle 2 */ ELL_3V_SUB( diff1, t2v2, t2v1 ); ELL_3V_SUB( diff2, t2v3, t2v1 ); ELL_3V_CROSS( n2, diff1, diff2 ); d2=-ELL_3V_DOT( n2, t2v1 ); t1sd1 = ELL_3V_DOT( n2, t1v1 )+d2; t1sd2 = ELL_3V_DOT( n2, t1v2 )+d2; t1sd3 = ELL_3V_DOT( n2, t1v3 )+d2; if ( t1sd1*t1sd2>=0 && t1sd1*t1sd3<=0 ) { t1s11=t1v1; t1s12=t1v2; t1s2=t1v3; t1s11sd=t1sd1; t1s12sd=t1sd2; t1s2sd=t1sd3; } else if ( t1sd1*t1sd3>=0 && t1sd1*t1sd2<=0 ) { t1s11=t1v1; t1s12=t1v3; t1s2=t1v2; t1s11sd=t1sd1; t1s12sd=t1sd3; t1s2sd=t1sd2; } else if ( t1sd2*t1sd3>=0 && t1sd1*t1sd2<=0 ) { t1s11=t1v2; t1s12=t1v3; t1s2=t1v1; t1s11sd=t1sd2; t1s12sd=t1sd3; t1s2sd=t1sd1; } else return 0; /* all on the same side; no intersection */ /* both planes intersect in a line; check if the intervals on that * line intersect */ ELL_3V_CROSS( D, n1, n2 ); /* we are only interested in component magnitudes */ D[0]=fabs( D[0] ); D[1]=fabs( D[1] ); D[2]=fabs( D[2] ); if ( D[0]>=D[1] && D[0]>=D[2] ) { t1p11=t1s11[0]; t1p12=t1s12[0]; t1p2=t1s2[0]; t2p11=t2s11[0]; t2p12=t2s12[0]; t2p2=t2s2[0]; } else if ( D[1]>=D[0] && D[1]>=D[2] ) { t1p11=t1s11[1]; t1p12=t1s12[1]; t1p2=t1s2[1]; t2p11=t2s11[1]; t2p12=t2s12[1]; t2p2=t2s2[1]; } else { t1p11=t1s11[2]; t1p12=t1s12[2]; t1p2=t1s2[2]; t2p11=t2s11[2]; t2p12=t2s12[2]; t2p2=t2s2[2]; } /* compute interval boundaries */ t1t1=t1p11+( t1p2-t1p11 )*t1s11sd/( t1s11sd-t1s2sd ); t1t2=t1p12+( t1p2-t1p12 )*t1s12sd/( t1s12sd-t1s2sd ); if ( t1t1>t1t2 ) { double help=t1t1; t1t1=t1t2; t1t2=help; } t2t1=t2p11+( t2p2-t2p11 )*t2s11sd/( t2s11sd-t2s2sd ); t2t2=t2p12+( t2p2-t2p12 )*t2s12sd/( t2s12sd-t2s2sd ); if ( t2t1>t2t2 ) { double help=t2t1; t2t1=t2t2; t2t2=help; } /* test for interval intersection */ if ( t2t1>t1t2 || t1t1>t2t2 ) return 0; return 1; } } /* Score possible local topologies based on the agreement of * connecting lines with normal directions. Lower scores are * better. */ /* Connections between degenerate points on cell faces; if only four * degenerate points are present, set p31 to NULL */ static double 867 evaluateDegConnection( double *p11, double *p12, double *p13, double *p14, double *p21, double *p22, double *p23, double *p24, double *p31, double *p32, double *p33, double *p34, double *n12, double *n13, double *n22, double *n23, double *n32, double *n33 ) { double diff1[3], diff2[3], diff3[3], ret; /* first, perform intersection testing */ if ( triIntersectionTest( p11, p12, p13, p21, p22, p23 ) || triIntersectionTest( p13, p14, p11, p21, p22, p23 ) || triIntersectionTest( p11, p12, p13, p23, p24, p21 ) || triIntersectionTest( p13, p14, p11, p23, p24, p21 ) ) return 1e20; if ( p31 != NULL ) { /* three pairs - some more to do */ if ( triIntersectionTest( p11, p12, p13, p31, p32, p33 ) || triIntersectionTest( p11, p12, p13, p33, p34, p31 ) || triIntersectionTest( p13, p14, p11, p31, p32, p33 ) || triIntersectionTest( p13, p14, p11, p33, p34, p31 ) || triIntersectionTest( p21, p22, p23, p31, p32, p33 ) || triIntersectionTest( p21, p22, p23, p33, p34, p31 ) || triIntersectionTest( p23, p24, p21, p31, p32, p33 ) || triIntersectionTest( p23, p24, p21, p33, p34, p31 ) ) return 1e20; } ELL_3V_SUB( diff1, p13, p12 ); ELL_3V_SUB( diff2, p23, p22 ); ret=fabs( ELL_3V_DOT( diff1, n12 ) )+fabs( ELL_3V_DOT( diff1, n13 ) )+ fabs( ELL_3V_DOT( diff2, n22 ) )+fabs( ELL_3V_DOT( diff2, n23 ) ); if ( p31 != NULL ) { ELL_3V_SUB( diff3, p33, p32 ); ret+=fabs( ELL_3V_DOT( diff3, n32 ) )+fabs( ELL_3V_DOT( diff3, n33 ) ); } return ret; } /* suggests a connectivity for a non-trivial combination of * intersection points in the plane. * pairs is output ( permutation of idcs ) * bestval is input/output ( best value so far, start with something big ) * ct is the number of points ( currently assumed even ) * idcs is input ( idcs that still need to be permuted ) * fixedct is input ( number of idcs that are already fixed at this depth ) * coords is an array of 2D coordinates * norms is an array of 2D vectors */ static void 911 findConnectivity( signed char *pairs, double *bestval, int ct, char *idcs, int fixedct, double *coords, double *norms ) { int i, j; if ( fixedct==ct ) { double weight=0; for ( i=0; i<ct-1; i+=2 ) { double diff[2]; ELL_2V_SUB( diff, coords+2*idcs[i], coords+2*idcs[i+1] ); weight+=fabs( ELL_2V_DOT( diff, norms+2*idcs[i] ) )+ fabs( ELL_2V_DOT( diff, norms+2*idcs[i+1] ) ); } if ( weight<*bestval ) { *bestval=weight; memcpy( pairs, idcs, sizeof( char )*ct ); } return; } /* else: we need a recursion */ for ( i=fixedct+1; i<ct; i++ ) { int intersect=0; char *idxnew; if ( NULL == ( idxnew = ( char* ) malloc ( sizeof( char )*ct ) ) ) return; memcpy( idxnew, idcs, sizeof( char )*ct ); /* try any of the remaining indices as a pair */ idxnew[fixedct+1]=idcs[i]; idxnew[i]=idcs[fixedct+1]; /* check if the resulting line causes an intersection */ for ( j=0;j<fixedct;j+=2 ) { if ( lineIntersectionTest( coords+2*idxnew[fixedct], coords+2*idxnew[fixedct+1], coords+2*idxnew[j], coords+2*idxnew[j+1] ) ) { intersect=1; break; } } if ( !intersect ) { findConnectivity( pairs, bestval, ct, idxnew, fixedct+2, coords, norms ); } free( idxnew ); } } #define _SEEK_TREATED_REQUEST 0x01 /* this voxel has to be treated */ #define _SEEK_TREATED_EDGE0 0x02 /* unique edge 0 has been treated */ #define _SEEK_TREATED_EDGE1 0x04 /* unique edge 1 has been treated */ #define _SEEK_TREATED_EDGE2 0x08 /* unique edge 2 has been treated */ #define _SEEK_TREATED_EDGE3 0x10 /* unique edge 3 has been treated */ #define _SEEK_TREATED_EDGE4 0x20 /* unique edge 4 has been treated */ #define _SEEK_TREATED_FACE3 0x40 /* unique face 3 has been treated */ /* find deg. points, normals, and connectivity on a given ( unique ) face * now refines the search if it couldn't find a degenerate point */ static void 965 connectFace( seekContext *sctx, baggage *bag, unsigned int xi, unsigned int yi, unsigned char faceid ) { int edgeid[4][4]={{0, 2, 3, 1}, /* which edges belong to which unique face? */ {0, 5, 8, 4}, {1, 6, 9, 4}, {8, 10, 11, 9}}; unsigned int sx = AIR_CAST( unsigned int, sctx->sx ); unsigned int si = xi + sx*yi; unsigned int six = xi + 1 + sx*yi; unsigned int siy = xi + sx*( yi+1 ); unsigned int sixy = xi + 1 + sx*( yi+1 ); char inter[12]; /* indices of intersections */ int pass; /* allow multiple refined passes */ int i; /* voxel in which treated information is stored for local edge i */ /* which vertices form which unique face? */ int verti[4][4]; int voxel[4][4]; /* mask for treated information in the above voxel */ char mask[4][4]={{_SEEK_TREATED_EDGE0, _SEEK_TREATED_EDGE1, _SEEK_TREATED_EDGE0, _SEEK_TREATED_EDGE1}, {_SEEK_TREATED_EDGE0, _SEEK_TREATED_EDGE2, _SEEK_TREATED_EDGE3, _SEEK_TREATED_EDGE2}, {_SEEK_TREATED_EDGE1, _SEEK_TREATED_EDGE2, _SEEK_TREATED_EDGE4, _SEEK_TREATED_EDGE2}, {_SEEK_TREATED_EDGE3, _SEEK_TREATED_EDGE4, _SEEK_TREATED_EDGE3, _SEEK_TREATED_EDGE4}}; /* start- and endpoints of the edges */ int verts[4][4], verte[4][4]; char treat[4]={0, 0, 0, 0}; double dpthresh[3]={0.7, 0.8, 0.9}; /* candidates for degenerate points */ double candidates[18]={0.5, 0.5, 0.25, 0.25, 0.25, 0.75, 0.75, 0.25, 0.75, 0.75, 0.5, 0.25, 0.25, 0.5, 0.75, 0.5, 0.6, 0.75}; int cand_idx[4]={0, 1, 5, 9}; int interct; /* apparently, some C compilers cannot make these initializations in-place */ ELL_4V_SET( verti[0], 0+2*si, 0+2*six, 0+2*siy, 0+2*sixy ); ELL_4V_SET( verti[1], 0+2*si, 0+2*six, 1+2*si, 1+2*six ); ELL_4V_SET( verti[2], 0+2*si, 0+2*siy, 1+2*si, 1+2*siy ); ELL_4V_SET( verti[3], 1+2*si, 1+2*six, 1+2*siy, 1+2*sixy ); ELL_4V_SET( voxel[0], si, six, siy, si ); ELL_4V_SET( voxel[1], si, six, si, si ); ELL_4V_SET( voxel[2], si, siy, si, si ); ELL_4V_SET( voxel[3], si, six, siy, si ); ELL_4V_SET( verts[0], 0+2*si, 0+2*six, 0+2*siy, 0+2*si ); ELL_4V_SET( verts[1], 0+2*si, 0+2*six, 1+2*si, 0+2*si ); ELL_4V_SET( verts[2], 0+2*si, 0+2*siy, 1+2*si, 0+2*si ); ELL_4V_SET( verts[3], 1+2*si, 1+2*six, 1+2*siy, 1+2*si ); ELL_4V_SET( verte[0], 0+2*six, 0+2*sixy, 0+2*sixy, 0+2*siy ); ELL_4V_SET( verte[1], 0+2*six, 1+2*six, 1+2*six, 1+2*si ); ELL_4V_SET( verte[2], 0+2*siy, 1+2*siy, 1+2*siy, 1+2*si ); ELL_4V_SET( verte[3], 1+2*six, 1+2*sixy, 1+2*sixy, 1+2*siy ); /* find out which edges have not yet been treated */ for ( i=0; i<4; i++ ) { if ( !( sctx->treated[voxel[faceid][i]]&mask[faceid][i] ) ) { treat[i]=1; /* we need to treat this */ sctx->treated[voxel[faceid][i]] |= mask[faceid][i]; } } for ( pass=0; pass<3; pass++ ) { /* first, find intersections for edges that need treatment */ int j; for ( j=0; j<4; j++ ) { double interpos[8]; if ( !treat[j] ) continue; interct=findFeatureIntersection( interpos, sctx->t + 9*verts[faceid][j], sctx->hess + 9*verts[faceid][j], sctx->grad + 3*verts[faceid][j], sctx->t + 9*verte[faceid][j], sctx->hess + 9*verte[faceid][j], sctx->grad + 3*verte[faceid][j], 0.0, 1.0, bag->esIdx==2, sctx->evalDiffThresh, dpthresh[pass] ); if ( interct>3 ) interct=3; for ( i=0; i<interct; i++ ) { double x=0, y=0, z=0; unsigned int xb=0, yb=0, idb=0; sctx->edgealpha[3*( bag->evti[edgeid[faceid][j]]+5*si )+i] = interpos[i]; switch ( edgeid[faceid][j] ) { case 0: x=xi+interpos[i]; y=yi; z=bag->zi; xb=xi; yb=yi; idb=0; break; case 1: x=xi; y=yi+interpos[i]; z=bag->zi; xb=xi; yb=yi; idb=1; break; case 2: x=xi+1; y=yi+interpos[i]; z=bag->zi; xb=xi+1; yb=yi; idb=1; break; case 3: x=xi+interpos[i]; y=yi+1; z=bag->zi; xb=xi; yb=yi+1; idb=0; break; case 4: x=xi; y=yi; z=bag->zi+interpos[i]; xb=xi; yb=yi; idb=2; break; case 5: x=xi+1; y=yi; z=bag->zi+interpos[i]; xb=xi+1; yb=yi; idb=2; break; case 6: x=xi; y=yi+1; z=bag->zi+interpos[i]; xb=xi; yb=yi+1; idb=2; break; case 7: x=xi+1; y=yi+1; z=bag->zi+interpos[i]; xb=xi+1; yb=yi+1; idb=2; break; case 8: x=xi+interpos[i]; y=yi; z=bag->zi+1; xb=xi; yb=yi; idb=3; break; case 9: x=xi; y=yi+interpos[i]; z=bag->zi+1; xb=xi; yb=yi; idb=4; break; case 10: x=xi+1; y=yi+interpos[i]; z=bag->zi+1; xb=xi+1; yb=yi; idb=4; break; case 11: x=xi+interpos[i]; y=yi+1; z=bag->zi+1; xb=xi; yb=yi+1; idb=3; break; } ELL_3V_SET( sctx->edgeicoord+9*( bag->evti[edgeid[faceid][j]]+5*si )+3*i, x, y, z ); computeEdgeGradient( sctx, bag, sctx->edgenorm+ 9*( bag->evti[edgeid[faceid][j]]+5*si )+3*i, xb, yb, idb, interpos[i] ); } } interct=0; /* number of feature intersections */ for ( i=0; i<3; i++ ) { if ( sctx->edgealpha[3*( bag->evti[edgeid[faceid][0]]+5*si )+i]>=0 ) inter[interct++]=i; /* numbering is local w.r.t. face */ if ( sctx->edgealpha[3*( bag->evti[edgeid[faceid][1]]+5*si )+i]>=0 ) inter[interct++]=3+i; if ( sctx->edgealpha[3*( bag->evti[edgeid[faceid][2]]+5*si )+i]>=0 ) inter[interct++]=6+i; if ( sctx->edgealpha[3*( bag->evti[edgeid[faceid][3]]+5*si )+i]>=0 ) inter[interct++]=9+i; } if ( interct%2==1 ) { /* we need to look for a degeneracy */ int k; for ( k=cand_idx[pass]; k<cand_idx[pass+1]; k++ ) { ELL_2V_SET( sctx->facecoord+2*( faceid+4*si ), candidates[2*k], candidates[2*k+1] ); if ( !seekDescendToDeg( sctx->facecoord+2*( faceid+4*si ), sctx->hess + 9*verti[faceid][0], sctx->hess + 9*verti[faceid][1], sctx->hess + 9*verti[faceid][2], sctx->hess + 9*verti[faceid][3], 50, 1e-9, ( bag->esIdx==2 )?'l':'p' ) ) { inter[interct++]=12; /* 12 means "deg. point on this face */ break; } } if ( ( pass==2 ) && ( inter[interct-1]!=12 ) ) { /* nothing helped, so insert a dummy vertex */ ELL_2V_SET( sctx->facecoord+2*( faceid+4*si ), 0.5, 0.5 ); inter[interct++]=12; } if ( inter[interct-1]==12 ) { computeFaceGradient( sctx, sctx->facenorm+3*( faceid+4*si ), xi, yi, faceid, sctx->facecoord+2*( faceid+4*si ) ); switch ( faceid ) { case 0: ELL_3V_SET( sctx->faceicoord+3*( faceid+4*si ), xi+sctx->facecoord[2*( faceid+4*si )], yi+sctx->facecoord[2*( faceid+4*si )+1], bag->zi ); break; case 1: ELL_3V_SET( sctx->faceicoord+3*( faceid+4*si ), xi+sctx->facecoord[2*( faceid+4*si )], yi, bag->zi+sctx->facecoord[2*( faceid+4*si )+1] ); break; case 2: ELL_3V_SET( sctx->faceicoord+3*( faceid+4*si ), xi, yi+sctx->facecoord[2*( faceid+4*si )], bag->zi+sctx->facecoord[2*( faceid+4*si )+1] ); break; case 3: ELL_3V_SET( sctx->faceicoord+3*( faceid+4*si ), xi+sctx->facecoord[2*( faceid+4*si )], yi+sctx->facecoord[2*( faceid+4*si )+1], bag->zi+1 ); break; } } } if ( interct%2==0 ) { /* we can break out */ break; } } if ( interct<=1 ) { /* there is no connectivity on this face */ ELL_4V_SET( sctx->pairs+12*( faceid+4*si ), -1, -1, -1, -1 ); } else if ( interct==2 ) { /* connectivity is straightforward */ ELL_4V_SET( sctx->pairs+12*( faceid+4*si ), inter[0], inter[1], -1, -1 ); } else { /* we need gradients and coordinates to make a decision */ double interc[24]; /* 2D coordinates of intersection points */ double intern[24]; /* 2D normals at intersection points */ /* used to find the best pairing without self-intersection */ double bestscore=1e20; char idcs[12]; /* consider if we need to restrict this */ for ( i=0; i<interct; i++ ) { if ( inter[i]<12 ) { /* edge feature */ int resolved=edgeid[faceid][inter[i]/3]; int offset=inter[i]%3; switch ( faceid ) { case 0: case 3: ELL_2V_SET( interc+2*i, sctx->edgeicoord[9*( bag->evti[resolved]+5*si )+3*offset], sctx->edgeicoord[9*( bag->evti[resolved]+5*si )+3*offset+1] ); ELL_2V_SET( intern+2*i, sctx->edgenorm[9*( bag->evti[resolved]+5*si )+3*offset], sctx->edgenorm[9*( bag->evti[resolved]+5*si )+3*offset+1] ); break; case 1: ELL_2V_SET( interc+2*i, sctx->edgeicoord[9*( bag->evti[resolved]+5*si )+3*offset], sctx->edgeicoord[9*( bag->evti[resolved]+5*si )+3*offset+2] ); ELL_2V_SET( intern+2*i, sctx->edgenorm[9*( bag->evti[resolved]+5*si )+3*offset], sctx->edgenorm[9*( bag->evti[resolved]+5*si )+3*offset+2] ); break; case 2: ELL_2V_SET( interc+2*i, sctx->edgeicoord[9*( bag->evti[resolved]+5*si )+3*offset+1], sctx->edgeicoord[9*( bag->evti[resolved]+5*si )+3*offset+2] ); ELL_2V_SET( intern+2*i, sctx->edgenorm[9*( bag->evti[resolved]+5*si )+3*offset+1], sctx->edgenorm[9*( bag->evti[resolved]+5*si )+3*offset+2] ); break; } } else { /* face feature */ switch ( faceid ) { case 0: case 3: ELL_2V_SET( interc+2*i, sctx->faceicoord[3*( faceid+4*si )], sctx->faceicoord[3*( faceid+4*si )+1] ); ELL_2V_SET( intern+2*i, sctx->facenorm[3*( faceid+4*si )], sctx->facenorm[3*( faceid+4*si )+1] ); break; case 1: ELL_2V_SET( interc+2*i, sctx->faceicoord[3*( faceid+4*si )], sctx->faceicoord[3*( faceid+4*si )+2] ); ELL_2V_SET( intern+2*i, sctx->facenorm[3*( faceid+4*si )], sctx->facenorm[3*( faceid+4*si )+2] ); break; case 2: ELL_2V_SET( interc+2*i, sctx->faceicoord[3*( faceid+4*si )+1], sctx->faceicoord[3*( faceid+4*si )+2] ); ELL_2V_SET( intern+2*i, sctx->facenorm[3*( faceid+4*si )+1], sctx->facenorm[3*( faceid+4*si )+2] ); break; } } } for ( i=0; i<interct; i++ ) { sctx->pairs[12*( faceid+4*si )+i]=i; idcs[i]=i; } findConnectivity( sctx->pairs+12*( faceid+4*si ), &bestscore, interct, idcs, 0, interc, intern ); for ( i=0; i<interct; i++ ) sctx->pairs[12*( faceid+4*si )+i]=inter[sctx->pairs[12*( faceid+4*si )+i]]; for ( i=interct; i<12; i++ ) sctx->pairs[12*( faceid+4*si )+i]=-1; } } static void 1219 intersectionShuffleProbe( seekContext *sctx, baggage *bag ) { unsigned int xi, yi, sx, sy, si; int i; sx = AIR_CAST( unsigned int, sctx->sx ); sy = AIR_CAST( unsigned int, sctx->sy ); for ( yi=0; yi<sy; yi++ ) { for ( xi=0; xi<sx; xi++ ) { si = xi + sx*yi; /* take care of facevidx array */ if ( !bag->zi ) { /* initialize, else copy over */ sctx->facevidx[0 + 4*si] = -1; } else { sctx->facevidx[0 + 4*si] = sctx->facevidx[3 + 4*si]; } sctx->facevidx[1 + 4*si] = sctx->facevidx[2 + 4*si] = sctx->facevidx[3 + 4*si] = -1; /* copy or reset data on the 5 unique edges */ if ( sctx->treated[si]&_SEEK_TREATED_EDGE3 ) { /* has been treated, just copy results */ ELL_3V_COPY( sctx->edgealpha+3*( 0+5*si ), sctx->edgealpha+3*( 3+5*si ) ); ELL_3M_COPY( sctx->edgenorm+9*( 0+5*si ), sctx->edgenorm+9*( 3+5*si ) ); ELL_3M_COPY( sctx->edgeicoord+9*( 0+5*si ), sctx->edgeicoord+9*( 3+5*si ) ); sctx->treated[si]|=_SEEK_TREATED_EDGE0; } else if ( xi!=sx-1 ) { ELL_3V_SET( sctx->edgealpha+3*( 0+5*si ), -1, -1, -1 ); sctx->treated[si]&=0xFF^_SEEK_TREATED_EDGE0; } if ( sctx->treated[si]&_SEEK_TREATED_EDGE4 ) { /* has been treated, just copy results */ ELL_3V_COPY( sctx->edgealpha+3*( 1+5*si ), sctx->edgealpha+3*( 4+5*si ) ); ELL_3M_COPY( sctx->edgenorm+9*( 1+5*si ), sctx->edgenorm+9*( 4+5*si ) ); ELL_3M_COPY( sctx->edgeicoord+9*( 1+5*si ), sctx->edgeicoord+9*( 4+5*si ) ); sctx->treated[si]|=_SEEK_TREATED_EDGE1; } else if ( yi!=sy-1 ) { ELL_3V_SET( sctx->edgealpha+3*( 1+5*si ), -1, -1, -1 ); sctx->treated[si]&=0xFF^_SEEK_TREATED_EDGE1; } /* edges within and at top of the slab are new */ ELL_3V_SET( sctx->edgealpha+3*( 2+5*si ), -1, -1, -1 ); sctx->treated[si]&=0xFF^_SEEK_TREATED_EDGE2; ELL_3V_SET( sctx->edgealpha+3*( 3+5*si ), -1, -1, -1 ); sctx->treated[si]&=0xFF^_SEEK_TREATED_EDGE3; ELL_3V_SET( sctx->edgealpha+3*( 4+5*si ), -1, -1, -1 ); sctx->treated[si]&=0xFF^_SEEK_TREATED_EDGE4; } } /* find missing deg. points, edge intersections, normals, and * connectivity on the four unique faces * this is done in a separate pass to make sure that all edge information * has been updated */ for ( yi=0; yi<sy; yi++ ) { for ( xi=0; xi<sx; xi++ ) { si = xi + sx*yi; if ( sctx->treated[si]&_SEEK_TREATED_FACE3 ) { /* we can copy previous results */ ELL_2V_COPY( sctx->facecoord+2*( 0+4*si ), sctx->facecoord+2*( 3+4*si ) ); ELL_3V_COPY( sctx->faceicoord+3*( 0+4*si ), sctx->faceicoord+3*( 3+4*si ) ); ELL_3V_COPY( sctx->facenorm+3*( 0+4*si ), sctx->facenorm+3*( 3+4*si ) ); for ( i=0; i<3; i++ ) ELL_4V_COPY( sctx->pairs+12*( 0+4*si )+4*i, sctx->pairs+12*( 3+4*si )+4*i ); } else if ( xi!=sx-1 && yi!=sy-1 ) { if ( sctx->treated[si]&_SEEK_TREATED_REQUEST ) connectFace( sctx, bag, xi, yi, 0 ); else ELL_4V_SET( sctx->pairs+12*( 0+4*si ), -1, -1, -1, -1 ); } if ( xi!=sx-1 ) { if ( sctx->treated[si]&_SEEK_TREATED_REQUEST || ( yi!=0 && sctx->treated[xi+sx*( yi-1 )]&_SEEK_TREATED_REQUEST ) ) connectFace( sctx, bag, xi, yi, 1 ); else ELL_4V_SET( sctx->pairs+12*( 1+4*si ), -1, -1, -1, -1 ); } if ( yi!=sy-1 ) { if ( sctx->treated[si]&_SEEK_TREATED_REQUEST || ( xi!=0 && sctx->treated[xi-1+sx*yi]&_SEEK_TREATED_REQUEST ) ) connectFace( sctx, bag, xi, yi, 2 ); else ELL_4V_SET( sctx->pairs+12*( 2+4*si ), -1, -1, -1, -1 ); if ( xi!=sx-1 ) { if ( sctx->treated[si]&_SEEK_TREATED_REQUEST ) { connectFace( sctx, bag, xi, yi, 3 ); sctx->treated[si]|=_SEEK_TREATED_FACE3; } else { ELL_4V_SET( sctx->pairs+12*( 3+4*si ), -1, -1, -1, -1 ); sctx->treated[si]&=0xFF^_SEEK_TREATED_FACE3; } } } } } } /* special triangulation routine for use with T-based extraction */ int 1321 _seekTriangulateT( seekContext *sctx, baggage *bag, limnPolyData *lpld ) { unsigned xi, yi, sx, sy, si, i; /* map edge indices w.r.t. faces ( as used in sctx->pairs ) back to * edge indices w.r.t. voxel */ char edges[6][5]={{0, 2, 3, 1, 12}, {0, 5, 8, 4, 13}, {2, 7, 10, 5, 14}, {3, 7, 11, 6, 15}, {1, 6, 9, 4, 16}, {8, 10, 11, 9, 17}}; sx = AIR_CAST( unsigned int, sctx->sx ); sy = AIR_CAST( unsigned int, sctx->sy ); for ( yi=0; yi<sy-1; yi++ ) { for ( xi=0; xi<sx-1; xi++ ) { int fvti[6]; /* indices into unique face array */ char connections[84];/* ( 12 edges * 3 possible intersections+6 faces )*2 */ char degeneracies[6]; int degct=0; unsigned int face; if ( sctx->strengthUse && sctx->stng[0+2*( xi+sx*yi )] < sctx->strength && sctx->stng[1+2*( xi+sx*yi )] < sctx->strength && sctx->stng[0+2*( xi+1+sx*yi )] < sctx->strength && sctx->stng[1+2*( xi+1+sx*yi )] < sctx->strength && sctx->stng[0+2*( xi+sx*( yi+1 ) )] < sctx->strength && sctx->stng[1+2*( xi+sx*( yi+1 ) )] < sctx->strength && sctx->stng[0+2*( xi+1+sx*( yi+1 ) )] < sctx->strength && sctx->stng[1+2*( xi+1+sx*( yi+1 ) )] < sctx->strength ) continue;/* all vertices below strength limit, do not create geometry */ si = xi + sx*yi; ELL_3V_SET( fvti, 0 + 4*si, 1 + 4*si, 2 + 4*( xi+1 + sx*yi ) ); ELL_3V_SET( fvti+3, 1 + 4*( xi + sx*( yi+1 ) ), 2 + 4*si, 3 + 4*si ); /* collect all intersection + connectivity info for this voxel */ memset( connections, -1, sizeof( connections ) ); for ( face=0; face<6; face++ ) { for ( i=0; i<6; i++ ) { int idx1, offset1, idx2, offset2, idxmap1, idxmap2; if ( sctx->pairs[12*fvti[face]+2*i]==-1 ) break; idx1=edges[face][sctx->pairs[12*fvti[face]+2*i]/3]; offset1=sctx->pairs[12*fvti[face]+2*i]%3; idx2=edges[face][sctx->pairs[12*fvti[face]+2*i+1]/3]; offset2=sctx->pairs[12*fvti[face]+2*i+1]%3; idxmap1=3*idx1+offset1; idxmap2=3*idx2+offset2; if ( idx1>11 ) { idxmap1=idx1+24; /* +36-12 */ degeneracies[degct++] = idxmap1; } if ( idx2>11 ) { idxmap2=idx2+24; degeneracies[degct++] = idxmap2; } if ( connections[2*idxmap1]==-1 ) connections[2*idxmap1]=idxmap2; else connections[2*idxmap1+1]=idxmap2; if ( connections[2*idxmap2]==-1 ) connections[2*idxmap2]=idxmap1; else connections[2*idxmap2+1]=idxmap1; } } /* connect the degenerate points */ if ( degct==2 ) { connections[2*degeneracies[0]+1]=degeneracies[1]; connections[2*degeneracies[1]+1]=degeneracies[0]; } else if ( degct==4 ) { int bestchoice=0; int eidcs[4], fidcs[4]; int k; double bestscore, score; for ( k=0; k<4; ++k ) { eidcs[k]=3*( bag->evti[connections[2*degeneracies[k]]/3]+5*si )+ connections[2*degeneracies[k]]%3; fidcs[k]=fvti[degeneracies[k]-36]; } bestscore=evaluateDegConnection( sctx->edgeicoord+3*eidcs[0], sctx->faceicoord+3*fidcs[0], sctx->faceicoord+3*fidcs[1], sctx->edgeicoord+3*eidcs[1], sctx->edgeicoord+3*eidcs[2], sctx->faceicoord+3*fidcs[2], sctx->faceicoord+3*fidcs[3], sctx->edgeicoord+3*eidcs[3], NULL, NULL, NULL, NULL, sctx->facenorm+3*fidcs[0], sctx->facenorm+3*fidcs[1], sctx->facenorm+3*fidcs[2], sctx->facenorm+3*fidcs[3], NULL, NULL ); score=evaluateDegConnection( sctx->edgeicoord+3*eidcs[0], sctx->faceicoord+3*fidcs[0], sctx->faceicoord+3*fidcs[2], sctx->edgeicoord+3*eidcs[2], sctx->edgeicoord+3*eidcs[1], sctx->faceicoord+3*fidcs[1], sctx->faceicoord+3*fidcs[3], sctx->edgeicoord+3*eidcs[3], NULL, NULL, NULL, NULL, sctx->facenorm+3*fidcs[0], sctx->facenorm+3*fidcs[2], sctx->facenorm+3*fidcs[1], sctx->facenorm+3*fidcs[3], NULL, NULL ); if ( score<bestscore ) { bestscore=score; bestchoice=1; } score=evaluateDegConnection( sctx->edgeicoord+3*eidcs[0], sctx->faceicoord+3*fidcs[0], sctx->faceicoord+3*fidcs[3], sctx->edgeicoord+3*eidcs[3], sctx->edgeicoord+3*eidcs[1], sctx->faceicoord+3*fidcs[1], sctx->faceicoord+3*fidcs[2], sctx->edgeicoord+3*eidcs[2], NULL, NULL, NULL, NULL, sctx->facenorm+3*fidcs[0], sctx->facenorm+3*fidcs[3], sctx->facenorm+3*fidcs[1], sctx->facenorm+3*fidcs[2], NULL, NULL ); if ( score<bestscore ) { bestscore=score; bestchoice=2; } switch ( bestchoice ) { case 0: connections[2*degeneracies[0]+1]=degeneracies[1]; connections[2*degeneracies[1]+1]=degeneracies[0]; connections[2*degeneracies[2]+1]=degeneracies[3]; connections[2*degeneracies[3]+1]=degeneracies[2]; break; case 1: connections[2*degeneracies[0]+1]=degeneracies[2]; connections[2*degeneracies[2]+1]=degeneracies[0]; connections[2*degeneracies[1]+1]=degeneracies[3]; connections[2*degeneracies[3]+1]=degeneracies[1]; break; case 2: connections[2*degeneracies[0]+1]=degeneracies[3]; connections[2*degeneracies[3]+1]=degeneracies[0]; connections[2*degeneracies[1]+1]=degeneracies[2]; connections[2*degeneracies[2]+1]=degeneracies[1]; break; } } else if ( degct==6 ) { int bestchoice=0; int eidcs[6], fidcs[6]; int k; double bestscore; int pairings[15][6]={{0, 1, 2, 3, 4, 5}, {0, 1, 2, 4, 3, 5}, {0, 1, 2, 5, 3, 4}, {0, 2, 1, 3, 4, 5}, {0, 2, 1, 4, 3, 5}, {0, 2, 1, 5, 3, 4}, {0, 3, 1, 2, 4, 5}, {0, 3, 1, 4, 2, 5}, {0, 3, 1, 5, 2, 4}, {0, 4, 1, 2, 3, 5}, {0, 4, 1, 3, 2, 5}, {0, 4, 1, 5, 2, 3}, {0, 5, 1, 2, 3, 4}, {0, 5, 1, 3, 2, 4}, {0, 5, 1, 4, 2, 3}}; for ( k=0; k<6; ++k ) { eidcs[k]=3*( bag->evti[connections[2*degeneracies[k]]/3]+5*si )+ connections[2*degeneracies[k]]%3; fidcs[k]=fvti[degeneracies[k]-36]; } bestscore=evaluateDegConnection( sctx->edgeicoord+3*eidcs[0], sctx->faceicoord+3*fidcs[0], sctx->faceicoord+3*fidcs[1], sctx->edgeicoord+3*eidcs[1], sctx->edgeicoord+3*eidcs[2], sctx->faceicoord+3*fidcs[2], sctx->faceicoord+3*fidcs[3], sctx->edgeicoord+3*eidcs[3], sctx->edgeicoord+3*eidcs[4], sctx->faceicoord+3*fidcs[4], sctx->faceicoord+3*fidcs[5], sctx->edgeicoord+3*eidcs[5], sctx->facenorm+3*fidcs[0], sctx->facenorm+3*fidcs[1], sctx->facenorm+3*fidcs[2], sctx->facenorm+3*fidcs[3], sctx->facenorm+3*fidcs[4], sctx->facenorm+3*fidcs[5] ); for ( k=1; k<15; ++k ) { double score=evaluateDegConnection ( sctx->edgeicoord+3*eidcs[pairings[k][0]], sctx->faceicoord+3*fidcs[pairings[k][0]], sctx->faceicoord+3*fidcs[pairings[k][1]], sctx->edgeicoord+3*eidcs[pairings[k][1]], sctx->edgeicoord+3*eidcs[pairings[k][2]], sctx->faceicoord+3*fidcs[pairings[k][2]], sctx->faceicoord+3*fidcs[pairings[k][3]], sctx->edgeicoord+3*eidcs[pairings[k][3]], sctx->edgeicoord+3*eidcs[pairings[k][4]], sctx->faceicoord+3*fidcs[pairings[k][4]], sctx->faceicoord+3*fidcs[pairings[k][5]], sctx->edgeicoord+3*eidcs[pairings[k][5]], sctx->facenorm+3*fidcs[pairings[k][0]], sctx->facenorm+3*fidcs[pairings[k][1]], sctx->facenorm+3*fidcs[pairings[k][2]], sctx->facenorm+3*fidcs[pairings[k][3]], sctx->facenorm+3*fidcs[pairings[k][4]], sctx->facenorm+3*fidcs[pairings[k][5]] ); if ( score<bestscore ) { bestscore=score; bestchoice=k; } } connections[2*degeneracies[pairings[bestchoice][0]]+1]= degeneracies[pairings[bestchoice][1]]; connections[2*degeneracies[pairings[bestchoice][1]]+1]= degeneracies[pairings[bestchoice][0]]; connections[2*degeneracies[pairings[bestchoice][2]]+1]= degeneracies[pairings[bestchoice][3]]; connections[2*degeneracies[pairings[bestchoice][3]]+1]= degeneracies[pairings[bestchoice][2]]; connections[2*degeneracies[pairings[bestchoice][4]]+1]= degeneracies[pairings[bestchoice][5]]; connections[2*degeneracies[pairings[bestchoice][5]]+1]= degeneracies[pairings[bestchoice][4]]; } /* sufficient to run to 36: each polygon will contain at least * one edge vertex */ for ( i=0; i<36; i++ ) { if ( connections[2*i]!=-1 ) { /* extract polygon from connections array */ signed char polygon[42]; unsigned char polyct=0; char thiz=i; char next=connections[2*i]; polygon[polyct++]=i; connections[2*i]=-1; while ( next!=-1 ) { char helpnext; polygon[polyct++]=next; if ( connections[2*next]==thiz ) { helpnext=connections[2*next+1]; } else { helpnext=connections[2*next]; } connections[2*next]=connections[2*next+1]=-1; thiz = next; next = helpnext; if ( next==polygon[0] ) break; /* polygon is closed */ } if ( next!=-1 ) { /* else: discard unclosed polygon */ /* make sure all required vertices are there */ int j; for ( j=0; j<polyct; ++j ) { double tvertA[4], tvertB[4]; if ( polygon[j]<36 ) { /* we may need to insert an edge vertex */ int eidx=3*( bag->evti[polygon[j]/3] + 5*si )+polygon[j]%3; if ( -1 == sctx->vidx[eidx] ) { int ovi; ELL_3V_COPY( tvertA, sctx->edgeicoord+3*eidx ); tvertA[3]=1.0; /* tvertB in input index space */ ELL_4MV_MUL( tvertB, sctx->txfIdx, tvertA ); /* tvertA in world space */ ELL_4MV_MUL( tvertA, sctx->shape->ItoW, tvertB ); ELL_4V_HOMOG( tvertA, tvertA ); ovi = sctx->vidx[eidx] = airArrayLenIncr( bag->xyzwArr, 1 ); ELL_4V_SET_TT( lpld->xyzw + 4*ovi, float, tvertA[0], tvertA[1], tvertA[2], 1.0 ); if ( sctx->normalsFind ) { double len=ELL_3V_LEN( sctx->edgenorm+3*eidx ); airArrayLenIncr( bag->normArr, 1 ); ELL_3V_SCALE_TT( lpld->norm + 3*ovi, float, 1.0/len, sctx->edgenorm+3*eidx ); } sctx->vertNum++; } } else { /* we may need to insert a face vertex */ int fidx=fvti[polygon[j]-36]; if ( -1 == sctx->facevidx[fidx] ) { int ovi; ELL_3V_COPY( tvertA, sctx->faceicoord+3*fidx ); tvertA[3]=1.0; /* tvertB in input index space */ ELL_4MV_MUL( tvertB, sctx->txfIdx, tvertA ); /* tvertA in world space */ ELL_4MV_MUL( tvertA, sctx->shape->ItoW, tvertB ); ELL_4V_HOMOG( tvertA, tvertA ); ovi = sctx->facevidx[fidx] = airArrayLenIncr( bag->xyzwArr, 1 ); ELL_4V_SET_TT( lpld->xyzw + 4*ovi, float, tvertA[0], tvertA[1], tvertA[2], 1.0 ); if ( sctx->normalsFind ) { double len=ELL_3V_LEN( sctx->facenorm+3*fidx ); airArrayLenIncr( bag->normArr, 1 ); ELL_3V_SCALE_TT( lpld->norm + 3*ovi, float, 1.0/len, sctx->facenorm+3*fidx ); } sctx->vertNum++; } } } if ( polyct>4 ) { /* we need to insert a helper vertex */ double tvertA[4], tvertB[4], tvertAsum[4]={0, 0, 0, 0}, normsum[3]={0, 0, 0}; int ovi; unsigned int vii[3]; for ( j=0; j<polyct; j++ ) { if ( polygon[j]<36 ) { int eidx=3*( bag->evti[polygon[j]/3] + 5*si )+polygon[j]%3; ELL_3V_COPY( tvertA, sctx->edgeicoord+3*eidx ); tvertA[3]=1.0; ELL_4V_INCR( tvertAsum, tvertA ); if ( ELL_3V_DOT( normsum, sctx->edgenorm+3*eidx )<0 ) ELL_3V_SUB( normsum, normsum, sctx->edgenorm+3*eidx ); else ELL_3V_INCR( normsum, sctx->edgenorm+3*eidx ); } else { int fidx=fvti[polygon[j]-36]; ELL_3V_COPY( tvertA, sctx->faceicoord+3*fidx ); tvertA[3]=1.0; ELL_4V_INCR( tvertAsum, tvertA ); if ( ELL_3V_DOT( normsum, sctx->facenorm+3*fidx )<0 ) ELL_3V_SUB( normsum, normsum, sctx->facenorm+3*fidx ); else ELL_3V_INCR( normsum, sctx->facenorm+3*fidx ); } } /* tvertB in input index space */ ELL_4MV_MUL( tvertB, sctx->txfIdx, tvertAsum ); /* tvertA in world space */ ELL_4MV_MUL( tvertA, sctx->shape->ItoW, tvertB ); ELL_4V_HOMOG( tvertA, tvertA ); ovi = airArrayLenIncr( bag->xyzwArr, 1 ); ELL_4V_SET_TT( lpld->xyzw + 4*ovi, float, tvertA[0], tvertA[1], tvertA[2], 1.0 ); if ( sctx->normalsFind ) { double len=ELL_3V_LEN( normsum ); airArrayLenIncr( bag->normArr, 1 ); ELL_3V_SCALE_TT( lpld->norm + 3*ovi, float, 1.0/len, normsum ); } sctx->vertNum++; vii[0]=ovi; vii[1]=sctx->vidx[3*( bag->evti[polygon[0]/3]+5*si )+polygon[0]%3]; for ( j=0; j<polyct; ++j ) { double edgeA[3], edgeB[3]; double norm[3]; vii[2]=vii[1]; if ( j==polyct-1 ) { if ( polygon[0]<36 ) vii[1]=sctx->vidx[3*( bag->evti[polygon[0]/3] + 5*si )+ polygon[0]%3]; else vii[1]=sctx->facevidx[fvti[polygon[0]-36]]; } else { if ( polygon[j+1]<36 ) vii[1]=sctx->vidx[3*( bag->evti[polygon[j+1]/3] + 5*si )+ polygon[j+1]%3]; else vii[1]=sctx->facevidx[fvti[polygon[j+1]-36]]; } /* check for degenerate tris */ ELL_3V_SUB( edgeA, lpld->xyzw+4*vii[1], lpld->xyzw+4*vii[0] ); ELL_3V_SUB( edgeB, lpld->xyzw+4*vii[2], lpld->xyzw+4*vii[0] ); ELL_3V_CROSS( norm, edgeA, edgeB ); if ( ELL_3V_DOT( norm, norm )!=0 ) { unsigned iii = airArrayLenIncr( bag->indxArr, 3 ); ELL_3V_COPY( lpld->indx + iii, vii ); lpld->icnt[0] += 3; sctx->faceNum++; } /* else: degeneracies are caused by intersections that * more or less coincide with a grid vertex. They * should be harmless, so just don't create * deg. triangles in this case */ } } else if ( polyct>2 ) { /* insert the actual triangles */ unsigned int vii[3], iii; if ( polygon[0]<36 ) vii[0]=sctx->vidx[3*( bag->evti[polygon[0]/3] + 5*si )+ polygon[0]%3]; else vii[0]=sctx->facevidx[fvti[polygon[0]-36]]; if ( polygon[1]<36 ) vii[1]=sctx->vidx[3*( bag->evti[polygon[1]/3] + 5*si )+ polygon[1]%3]; else vii[1]=sctx->facevidx[fvti[polygon[1]-36]]; if ( polygon[2]<36 ) vii[2]=sctx->vidx[3*( bag->evti[polygon[2]/3] + 5*si )+ polygon[2]%3]; else vii[2]=sctx->facevidx[fvti[polygon[2]-36]]; iii = airArrayLenIncr( bag->indxArr, 3 ); ELL_3V_COPY( lpld->indx + iii, vii ); lpld->icnt[0] += 3; sctx->faceNum++; if ( polyct==4 ) { vii[1]=vii[2]; if ( polygon[3]<36 ) vii[2]=sctx->vidx[3*( bag->evti[polygon[3]/3] + 5*si )+ polygon[3]%3]; else vii[2]=sctx->facevidx[fvti[polygon[3]-36]]; iii = airArrayLenIncr( bag->indxArr, 3 ); ELL_3V_COPY( lpld->indx + iii, vii ); lpld->icnt[0] += 3; sctx->faceNum++; } } } } } } } return 0; } static void 1744 shuffleT( seekContext *sctx, baggage *bag ) { unsigned int xi, yi, sx, sy, si; sx = AIR_CAST( unsigned int, sctx->sx ); sy = AIR_CAST( unsigned int, sctx->sy ); if ( sctx->strengthUse ) { /* requests need to be cleared initially */ for ( yi=0; yi<sy; yi++ ) { for ( xi=0; xi<sx; xi++ ) { sctx->treated[xi+sx*yi] &= 0xFF^_SEEK_TREATED_REQUEST; } } } /* else, the request bits are always on */ for ( yi=0; yi<sy; yi++ ) { for ( xi=0; xi<sx; xi++ ) { si = xi + sx*yi; /* vidx neither needs past nor future context */ if ( !bag->zi ) { ELL_3V_SET( sctx->vidx+3*( 0+5*si ), -1, -1, -1 ); ELL_3V_SET( sctx->vidx+3*( 1+5*si ), -1, -1, -1 ); } else { ELL_3V_COPY( sctx->vidx+3*( 0+5*si ), sctx->vidx+3*( 3+5*si ) ); ELL_3V_COPY( sctx->vidx+3*( 1+5*si ), sctx->vidx+3*( 4+5*si ) ); } ELL_3V_SET( sctx->vidx+3*( 2+5*si ), -1, -1, -1 ); ELL_3V_SET( sctx->vidx+3*( 3+5*si ), -1, -1, -1 ); ELL_3V_SET( sctx->vidx+3*( 4+5*si ), -1, -1, -1 ); /* strength only has future context */ if ( sctx->strengthUse ) { sctx->stng[0 + 2*si] = sctx->stng[1 + 2*si]; sctx->stng[1 + 2*si] = sctx->stngcontext[si]; if ( sctx->stng[0+2*si]>sctx->strength || sctx->stng[1+2*si]>sctx->strength ) { /* set up to four request bits */ sctx->treated[si] |= _SEEK_TREATED_REQUEST; if ( xi!=0 ) sctx->treated[xi-1+sx*yi] |= _SEEK_TREATED_REQUEST; if ( yi!=0 ) sctx->treated[xi+sx*( yi-1 )] |= _SEEK_TREATED_REQUEST; if ( xi!=0 && yi!=0 ) sctx->treated[xi-1+sx*( yi-1 )] |= _SEEK_TREATED_REQUEST; } } /* shuffle grad, hess and t in three steps: move to past context, * shuffle in slab itself, move from future context */ ELL_3V_COPY( sctx->gradcontext + 3*( 0+2*si ), sctx->grad + 3*( 0+2*si ) ); ELL_3V_COPY( sctx->grad + 3*( 0+2*si ), sctx->grad + 3*( 1+2*si ) ); ELL_3V_COPY( sctx->grad + 3*( 1+2*si ), sctx->gradcontext + 3*( 1+2*si ) ); ELL_3M_COPY( sctx->hesscontext + 9*( 0+2*si ), sctx->hess + 9*( 0+2*si ) ); ELL_3M_COPY( sctx->hess + 9*( 0+2*si ), sctx->hess + 9*( 1+2*si ) ); ELL_3M_COPY( sctx->hess + 9*( 1+2*si ), sctx->hesscontext + 9*( 1+2*si ) ); ELL_3M_COPY( sctx->tcontext + 9*( 0+2*si ), sctx->t + 9*( 0+2*si ) ); ELL_3M_COPY( sctx->t + 9*( 0+2*si ), sctx->t + 9*( 1+2*si ) ); ELL_3M_COPY( sctx->t + 9*( 1+2*si ), sctx->tcontext + 9*( 1+2*si ) ); } } } static void 1808 probeT( seekContext *sctx, baggage *bag, double zi ) { unsigned int xi, yi, sx, sy, si; sx = AIR_CAST( unsigned int, sctx->sx ); sy = AIR_CAST( unsigned int, sctx->sy ); for ( yi=0; yi<sy; yi++ ) { for ( xi=0; xi<sx; xi++ ) { si = xi + sx*yi; if ( sctx->gctx ) { /* HEY: need this check, what's the right way? */ _seekIdxProbe( sctx, bag, xi, yi, zi ); } if ( sctx->strengthUse ) { sctx->stngcontext[si] = sctx->strengthSign*sctx->stngAns[0]; if ( sctx->strengthSeenMax==AIR_NAN ) { sctx->strengthSeenMax = sctx->stngcontext[si]; } sctx->strengthSeenMax = AIR_MAX( sctx->strengthSeenMax, sctx->stngcontext[si] ); } ELL_3V_COPY( sctx->gradcontext + 3*( 1 + 2*si ), sctx->gradAns ); ELL_3M_COPY( sctx->hesscontext + 9*( 1 + 2*si ), sctx->hessAns ); _seekHess2T( sctx->tcontext + 9*( 1 + 2*si ), sctx->evalAns, sctx->evecAns, sctx->evalDiffThresh, ( sctx->type==seekTypeRidgeSurfaceT ) ); } } } /* it has now become much easier to make this its own routine * ( vs. adding many more case distinctions to shuffleProbe ) * this only duplicates little ( and trivial ) code */ int 1841 _seekShuffleProbeT( seekContext *sctx, baggage *bag ) { /* for high-quality normal estimation, we need two slices of data * context; to keep the code simple, separate shuffle and probe * operations - let's hope this doesn't destroy cache performance */ if ( !bag->zi ) { if ( sctx->strengthUse ) /* before the first round, initialize treated to zero */ memset( sctx->treated, 0, sizeof( char )*sctx->sx*sctx->sy ); else /* request all edges */ memset( sctx->treated, _SEEK_TREATED_REQUEST, sizeof( char )*sctx->sx*sctx->sy ); probeT( sctx, bag, 0 ); shuffleT( sctx, bag ); probeT( sctx, bag, 1 ); } shuffleT( sctx, bag ); if ( bag->zi!=sctx->sz-2 ) probeT( sctx, bag, bag->zi+2 ); intersectionShuffleProbe( sctx, bag ); return 0; } /* For all vertices in pld, use sctx to probe the strength measure, * and return the answer ( times strengthSign ) in nval. The intended * use is postfiltering ( with limnPolyDataClip ), which is obligatory * when using seekType*SurfaceT * * Returns 1 and adds a message to biff upon error * Returns 0 on success, -n when probing n vertices failed ( strength * is set to AIR_NAN for those ); note that positions outside the field * are clamped to lie on its boundary. * * This routine assumes that a strength has been set in sctx and * seekUpdate( ) has been run. * This routine does not modify sctx->strengthSeenMax. */ int 1881 seekVertexStrength( Nrrd *nval, seekContext *sctx, limnPolyData *pld ) { static const char me[]="seekVertexStrength"; unsigned int i; double *data; int E=0; if ( !( nval && sctx && pld ) ) { biffAddf( SEEK, "%s: got NULL pointer", me ); return 1; } if ( !( sctx->gctx && sctx->pvl ) ) { biffAddf( SEEK, "%s: need sctx with attached gageContext", me ); return 1; } if ( !sctx->stngAns ) { biffAddf( SEEK, "%s: no strength item found. Did you enable strengthUse?", me ); return 1; } if ( nrrdAlloc_va( nval, nrrdTypeDouble, 1, ( size_t ) pld->xyzwNum ) ) { biffAddf( SEEK, "%s: could not allocate output", me ); return 1; } data = ( double* ) nval->data; for ( i=0; i<pld->xyzwNum; i++ ) { float homog[4]; ELL_4V_HOMOG( homog, pld->xyzw+4*i ); if ( !gageProbeSpace( sctx->gctx, homog[0], homog[1], homog[2], 0, 1 ) ) { *( data++ )=*( sctx->stngAns )*sctx->strengthSign; } else { *( data++ )=AIR_NAN; E--; } } return E; }

/Users/scm/git/github/teem/src/seek/updateSeek.c

1 /* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2009 Thomas Schultz Copyright ( C ) 2008, 2007, 2006, 2005 Gordon Kindlmann Copyright ( C ) 2004, 2003, 2002, 2001, 2000, 1999, 1998 University of Utah This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "seek.h" #include "privateSeek.h" static int 28 updateNinEtAl( seekContext *sctx ) { static const char me[]="updateNinEtAl"; if ( sctx->verbose > 5 ) { fprintf( stderr, "%s: --------------------\n", me ); fprintf( stderr, "%s: flagData = %d\n", me, sctx->flag[flagData] ); } if ( !( sctx->ninscl || sctx->pvl ) ) { biffAddf( SEEK, "%s: data never set", me ); return 1; } if ( sctx->flag[flagData] ) { if ( sctx->ninscl ) { sctx->nin = sctx->ninscl; sctx->baseDim = 0; if ( gageShapeSet( sctx->_shape, sctx->ninscl, 0 ) ) { biffMovef( SEEK, GAGE, "%s: trouble with scalar volume", me ); return 1; } sctx->shape = sctx->_shape; } else { sctx->nin = sctx->pvl->nin; sctx->baseDim = sctx->pvl->kind->baseDim; sctx->shape = sctx->gctx->shape; } sctx->flag[flagData] = AIR_FALSE; sctx->flag[flagNinEtAl] = AIR_TRUE; } return 0; } static int 62 updateAnswerPointers( seekContext *sctx ) { static const char me[]="updateAnswerPointers"; if ( sctx->verbose > 5 ) { fprintf( stderr, "%s: --------------------\n", me ); fprintf( stderr, "%s: flagItemValue = %d\n", me, sctx->flag[flagItemValue] ); fprintf( stderr, "%s: flagItemStrength = %d\n", me, sctx->flag[flagItemStrength] ); fprintf( stderr, "%s: flagItemNormal = %d\n", me, sctx->flag[flagItemNormal] ); fprintf( stderr, "%s: flagItemGradient = %d\n", me, sctx->flag[flagItemGradient] ); fprintf( stderr, "%s: flagItemEigensystem = %d\n", me, sctx->flag[flagItemEigensystem] ); fprintf( stderr, "%s: flagItemHess = %d\n", me, sctx->flag[flagItemHess] ); fprintf( stderr, "%s: flagNinEtAl = %d\n", me, sctx->flag[flagNinEtAl] ); fprintf( stderr, "%s: flagNormalsFind = %d\n", me, sctx->flag[flagNormalsFind] ); fprintf( stderr, "%s: flagStrengthUse = %d\n", me, sctx->flag[flagStrengthUse] ); fprintf( stderr, "%s: flagType = %d\n", me, sctx->flag[flagType] ); fprintf( stderr, "%s: flagData = %d\n", me, sctx->flag[flagData] ); } if ( seekTypeUnknown == sctx->type ) { biffAddf( SEEK, "%s: feature type never set", me ); return 1; } if ( sctx->flag[flagItemValue] || sctx->flag[flagItemStrength] || sctx->flag[flagItemNormal] || sctx->flag[flagItemGradient] || sctx->flag[flagItemEigensystem] || sctx->flag[flagItemHess] || sctx->flag[flagNinEtAl] || sctx->flag[flagNormalsFind] || sctx->flag[flagStrengthUse] || sctx->flag[flagType] ) { /* this is apt regardless of feature type */ if ( sctx->strengthUse ) { if ( -1 == sctx->stngItem ) { biffAddf( SEEK, "%s: need to set strength item to use strength", me ); return 1; } sctx->stngAns = ( gageAnswerPointer( sctx->gctx, sctx->pvl, sctx->stngItem ) ); } else { sctx->stngAns = NULL; } switch ( sctx->type ) { case seekTypeIsocontour: if ( !( sctx->ninscl || -1 != sctx->sclvItem ) ) { biffAddf( SEEK, "%s: need either scalar volume or value item set for %s", me, airEnumStr( seekType, seekTypeIsocontour ) ); return 1; } if ( sctx->normalsFind ) { /* NOTE simplifying assumption described in seek.h */ if ( !( sctx->ninscl || -1 != sctx->normItem ) ) { biffAddf( SEEK, "%s: need either scalar volume or " "normal item set for normals for %s", me, airEnumStr( seekType, seekTypeIsocontour ) ); return 1; } } if ( sctx->ninscl ) { sctx->sclvAns = NULL; sctx->normAns = NULL; } else { sctx->sclvAns = gageAnswerPointer( sctx->gctx, sctx->pvl, sctx->sclvItem ); sctx->normAns = ( sctx->normalsFind ? gageAnswerPointer( sctx->gctx, sctx->pvl, sctx->normItem ) : NULL ); } if ( sctx->flag[flagItemGradient] || sctx->flag[flagItemEigensystem] || sctx->flag[flagItemHess] ) { biffAddf( SEEK, "%s: can't set gradient, Hessian, or eigensystem for %s", me, airEnumStr( seekType, seekTypeIsocontour ) ); return 1; } sctx->gradAns = NULL; sctx->evalAns = NULL; sctx->evecAns = NULL; sctx->hessAns = NULL; break; case seekTypeRidgeSurface: case seekTypeValleySurface: case seekTypeMaximalSurface: case seekTypeMinimalSurface: case seekTypeRidgeSurfaceOP: case seekTypeRidgeSurfaceT: case seekTypeValleySurfaceOP: case seekTypeValleySurfaceT: if ( !sctx->pvl ) { biffAddf( SEEK, "%s: can't find %s without a gage context", me, airEnumStr( seekType, sctx->type ) ); return 1; } if ( !( -1 != sctx->gradItem && -1 != sctx->evalItem && -1 != sctx->evecItem ) ) { biffAddf( SEEK, "%s: grad, eval, evec items not all set", me ); return 1; } if ( ( sctx->type==seekTypeRidgeSurfaceT || sctx->type==seekTypeValleySurfaceT ) && -1 == sctx->hessItem ) { biffAddf( SEEK, "%s: hess item not set", me ); return 1; } if ( sctx->normalsFind ) { /* NOTE simplifying assumption described in seek.h */ if ( -1 == sctx->normItem ) { biffAddf( SEEK, "%s: need normal item set for normals for %s", me, airEnumStr( seekType, sctx->type ) ); return 1; } sctx->normAns = ( gageAnswerPointer( sctx->gctx, sctx->pvl, sctx->normItem ) ); } else { sctx->normAns = NULL; } sctx->sclvAns = NULL; sctx->gradAns = gageAnswerPointer( sctx->gctx, sctx->pvl, sctx->gradItem ); sctx->evalAns = gageAnswerPointer( sctx->gctx, sctx->pvl, sctx->evalItem ); sctx->evecAns = gageAnswerPointer( sctx->gctx, sctx->pvl, sctx->evecItem ); if ( sctx->type==seekTypeRidgeSurfaceT || sctx->type==seekTypeValleySurfaceT ) sctx->hessAns = gageAnswerPointer( sctx->gctx, sctx->pvl, sctx->hessItem ); else sctx->hessAns = NULL; break; default: biffAddf( SEEK, "%s: sorry, %s extraction not implemented", me, airEnumStr( seekType, sctx->type ) ); return 1; } sctx->flag[flagItemValue] = AIR_FALSE; sctx->flag[flagItemStrength] = AIR_FALSE; sctx->flag[flagItemNormal] = AIR_FALSE; sctx->flag[flagItemGradient] = AIR_FALSE; sctx->flag[flagItemEigensystem] = AIR_FALSE; sctx->flag[flagItemHess] = AIR_FALSE; sctx->flag[flagNormalsFind] = AIR_FALSE; sctx->flag[flagAnswerPointers] = AIR_TRUE; } return 0; } static int 228 updateSxSySz( seekContext *sctx ) { static const char me[]="updateSxSySz"; size_t sizeIn[3], sizeOut[3]; double min, max, scl[3], off[3]; unsigned int axi; if ( sctx->verbose > 5 ) { fprintf( stderr, "%s: --------------------\n", me ); fprintf( stderr, "%s: flagSamples = %d\n", me, sctx->flag[flagSamples] ); fprintf( stderr, "%s: flagNinEtAl = %d\n", me, sctx->flag[flagNinEtAl] ); } sizeIn[0] = sctx->nin->axis[sctx->baseDim+0].size; sizeIn[1] = sctx->nin->axis[sctx->baseDim+1].size; sizeIn[2] = sctx->nin->axis[sctx->baseDim+2].size; if ( sctx->flag[flagSamples] || sctx->flag[flagNinEtAl] ) { if ( 0 == sctx->samples[0] || 0 == sctx->samples[1] || 0 == sctx->samples[2] ) { ELL_3V_COPY( sizeOut, sizeIn ); } else { if ( !sctx->pvl ) { biffAddf( SEEK, "%s: can't specify # samples ( %u, %u, %u ) independent of " "volume dimensions ( %u, %u, %u ) without a gage context", me, AIR_CAST( unsigned int, sctx->samples[0] ), AIR_CAST( unsigned int, sctx->samples[1] ), AIR_CAST( unsigned int, sctx->samples[2] ), AIR_CAST( unsigned int, sizeIn[0] ), AIR_CAST( unsigned int, sizeIn[1] ), AIR_CAST( unsigned int, sizeIn[2] ) ); return 1; } ELL_3V_COPY( sizeOut, sctx->samples ); } /* want to make absolutely sure txfIdx was being set ... if ( sctx->sx != sizeOut[0] || sctx->sy != sizeOut[1] || sctx->sz != sizeOut[2] ) { */ sctx->sx = sizeOut[0]; sctx->sy = sizeOut[1]; sctx->sz = sizeOut[2]; /* there has got to be a better way of doing this... */ /* perhaps refer to the way origin is calculated in new nrrd resampler? */ for ( axi=0; axi<3; axi++ ) { min = ( nrrdCenterCell == sctx->shape->center ? -0.5 : 0.0 ); max = ( nrrdCenterCell == sctx->shape->center ? sizeIn[axi] - 0.5 : sizeIn[axi] - 1.0 ); off[axi] = NRRD_POS( sctx->shape->center, min, max, sizeOut[axi], 0 ); scl[axi] = ( NRRD_POS( sctx->shape->center, min, max, sizeOut[axi], 1 ) - off[axi] ); } ELL_4V_SET( sctx->txfIdx + 0*4, scl[0], 0.0, 0.0, off[0] ); ELL_4V_SET( sctx->txfIdx + 1*4, 0.0, scl[1], 0.0, off[1] ); ELL_4V_SET( sctx->txfIdx + 2*4, 0.0, 0.0, scl[2], off[2] ); ELL_4V_SET( sctx->txfIdx + 3*4, 0.0, 0.0, 0.0, 1.0 ); sctx->flag[flagSxSySz] = AIR_TRUE; sctx->flag[flagSamples] = AIR_FALSE; } return 0; } static int 296 updateReverse( seekContext *sctx ) { static const char me[]="updateReverse"; if ( sctx->verbose > 5 ) { fprintf( stderr, "%s: --------------------\n", me ); fprintf( stderr, "%s: flagNinEtAl = %d\n", me, sctx->flag[flagNinEtAl] ); fprintf( stderr, "%s: flagLowerInside = %d\n", me, sctx->flag[flagLowerInside] ); } if ( sctx->flag[flagNinEtAl] || sctx->flag[flagLowerInside] ) { double mat[9]; int reverse; ELL_34M_EXTRACT( mat, sctx->shape->ItoW ); reverse = ( !!sctx->lowerInside ) ^ ( ELL_3M_DET( mat ) < 0 ); if ( sctx->reverse != reverse ) { sctx->reverse = reverse; sctx->flag[flagReverse] = AIR_TRUE; } } return 0; } static int 323 updateTxfNormal( seekContext *sctx ) { static const char me[]="updateTxfNormal"; if ( sctx->verbose > 5 ) { fprintf( stderr, "%s: --------------------\n", me ); fprintf( stderr, "%s: flagNinEtAl = %d\n", me, sctx->flag[flagNinEtAl] ); fprintf( stderr, "%s: flagLowerInside = %d\n", me, sctx->flag[flagLowerInside] ); } if ( sctx->flag[flagNinEtAl] || sctx->flag[flagLowerInside] ) { double matA[9], matB[9]; ELL_34M_EXTRACT( matA, sctx->shape->ItoW ); ell_3m_inv_d( matB, matA ); ELL_3M_TRANSPOSE( sctx->txfNormal, matB ); if ( !sctx->lowerInside ) { ELL_3M_SCALE( sctx->txfNormal, -1, sctx->txfNormal ); } sctx->flag[flagTxfNormal] = AIR_TRUE; } sctx->flag[flagLowerInside] = AIR_FALSE; return 0; } static int 351 updateSlabCacheAlloc( seekContext *sctx ) { static const char me[]="updateSlabCacheAlloc"; int E; if ( sctx->verbose > 5 ) { fprintf( stderr, "%s: --------------------\n", me ); fprintf( stderr, "%s: flagType = %d ( type = %s )\n", me, sctx->flag[flagType], airEnumStr( seekType, sctx->type ) ); fprintf( stderr, "%s: flagStrengthUse = %d\n", me, sctx->flag[flagStrengthUse] ); fprintf( stderr, "%s: flagSxSySz = %d\n", me, sctx->flag[flagSxSySz] ); } E = 0; if ( sctx->flag[flagType] || sctx->flag[flagStrengthUse] /* kind of sloppy/overkill */ || sctx->flag[flagSxSySz] ) { if ( !E ) E |= nrrdMaybeAlloc_va( sctx->nvidx, nrrdTypeInt, 3, AIR_CAST( size_t, 15 ), sctx->sx, sctx->sy ); if ( !E ) sctx->vidx = AIR_CAST( int*, sctx->nvidx->data ); if ( !E ) E |= nrrdMaybeAlloc_va( sctx->ntreated, nrrdTypeChar, 2, sctx->sx, sctx->sy ); if ( !E ) sctx->treated = AIR_CAST( signed char*, sctx->ntreated->data ); if ( sctx->strengthUse ) { if ( !E ) E |= nrrdMaybeAlloc_va( sctx->nstng, nrrdTypeDouble, 3, AIR_CAST( size_t, 2 ), sctx->sx, sctx->sy ); if ( !E ) sctx->stng = AIR_CAST( double*, sctx->nstng->data ); } if ( seekTypeIsocontour == sctx->type ) { if ( !E ) E |= nrrdMaybeAlloc_va( sctx->nsclv, nrrdTypeDouble, 3, AIR_CAST( size_t, 4 ), sctx->sx + 2, sctx->sy + 2 ); if ( !E ) sctx->sclv = AIR_CAST( double*, sctx->nsclv->data ); } if ( seekTypeRidgeSurface == sctx->type || seekTypeValleySurface == sctx->type || seekTypeMaximalSurface == sctx->type || seekTypeMinimalSurface == sctx->type || seekTypeRidgeSurfaceOP == sctx->type || seekTypeRidgeSurfaceT == sctx->type || seekTypeValleySurfaceOP == sctx->type || seekTypeValleySurfaceT == sctx->type ) { if ( !E ) E |= nrrdMaybeAlloc_va( sctx->ngrad, nrrdTypeDouble, 4, AIR_CAST( size_t, 3 ), AIR_CAST( size_t, 2 ), sctx->sx, sctx->sy ); if ( !E ) sctx->grad = AIR_CAST( double*, sctx->ngrad->data ); } else { sctx->grad = NULL; } if ( seekTypeRidgeSurface == sctx->type || seekTypeValleySurface == sctx->type || seekTypeMaximalSurface == sctx->type || seekTypeMinimalSurface == sctx->type || seekTypeRidgeSurfaceOP == sctx->type || seekTypeValleySurfaceOP == sctx->type ) { if ( !E ) E |= nrrdMaybeAlloc_va( sctx->neval, nrrdTypeDouble, 4, AIR_CAST( size_t, 3 ), AIR_CAST( size_t, 2 ), sctx->sx, sctx->sy ); if ( !E ) sctx->eval = AIR_CAST( double*, sctx->neval->data ); if ( !E ) E |= nrrdMaybeAlloc_va( sctx->nevec, nrrdTypeDouble, 4, AIR_CAST( size_t, 9 ), AIR_CAST( size_t, 2 ), sctx->sx, sctx->sy ); if ( !E ) sctx->evec = AIR_CAST( double*, sctx->nevec->data ); if ( !E ) E |= nrrdMaybeAlloc_va( sctx->nflip, nrrdTypeChar, 3, AIR_CAST( size_t, 5 ), sctx->sx, sctx->sy ); if ( !E ) sctx->flip = AIR_CAST( signed char*, sctx->nflip->data ); } else { sctx->eval = NULL; sctx->evec = NULL; sctx->flip = NULL; } if ( seekTypeRidgeSurfaceT == sctx->type || seekTypeValleySurfaceT == sctx->type ) { if ( !E ) E |= nrrdMaybeAlloc_va( sctx->nfacevidx, nrrdTypeInt, 3, AIR_CAST( size_t, 4 ), sctx->sx, sctx->sy ); if ( !E ) sctx->facevidx = AIR_CAST( int*, sctx->nfacevidx->data ); if ( !E ) E |= nrrdMaybeAlloc_va( sctx->nhess, nrrdTypeDouble, 4, AIR_CAST( size_t, 9 ), AIR_CAST( size_t, 2 ), sctx->sx, sctx->sy ); if ( !E ) sctx->hess = AIR_CAST( double*, sctx->nhess->data ); if ( !E ) E |= nrrdMaybeAlloc_va( sctx->nt, nrrdTypeDouble, 4, AIR_CAST( size_t, 9 ), AIR_CAST( size_t, 2 ), sctx->sx, sctx->sy ); if ( !E ) sctx->t = AIR_CAST( double*, sctx->nt->data ); if ( !E ) E |= nrrdMaybeAlloc_va( sctx->nedgealpha, nrrdTypeDouble, 4, AIR_CAST( size_t, 5 ), AIR_CAST( size_t, 3 ), sctx->sx, sctx->sy ); if ( !E ) sctx->edgealpha = AIR_CAST( double*, sctx->nedgealpha->data ); if ( !E ) E |= nrrdMaybeAlloc_va( sctx->nedgenorm, nrrdTypeDouble, 4, AIR_CAST( size_t, 5 ), AIR_CAST( size_t, 9 ), sctx->sx, sctx->sy ); if ( !E ) sctx->edgenorm = AIR_CAST( double*, sctx->nedgenorm->data ); if ( !E ) E |= nrrdMaybeAlloc_va( sctx->nedgeicoord, nrrdTypeDouble, 4, AIR_CAST( size_t, 5 ), AIR_CAST( size_t, 9 ), sctx->sx, sctx->sy ); if ( !E ) sctx->edgeicoord = AIR_CAST( double*, sctx->nedgeicoord->data ); if ( !E ) E |= nrrdMaybeAlloc_va( sctx->nfacecoord, nrrdTypeDouble, 4, AIR_CAST( size_t, 4 ), AIR_CAST( size_t, 2 ), sctx->sx, sctx->sy ); if ( !E ) sctx->facecoord = AIR_CAST( double*, sctx->nfacecoord->data ); if ( !E ) E |= nrrdMaybeAlloc_va( sctx->nfacenorm, nrrdTypeDouble, 4, AIR_CAST( size_t, 4 ), AIR_CAST( size_t, 3 ), sctx->sx, sctx->sy ); if ( !E ) sctx->facenorm = AIR_CAST( double*, sctx->nfacenorm->data ); if ( !E ) E |= nrrdMaybeAlloc_va( sctx->nfaceicoord, nrrdTypeDouble, 4, AIR_CAST( size_t, 4 ), AIR_CAST( size_t, 3 ), sctx->sx, sctx->sy ); if ( !E ) sctx->faceicoord = AIR_CAST( double*, sctx->nfaceicoord->data ); if ( !E ) E |= nrrdMaybeAlloc_va( sctx->npairs, nrrdTypeChar, 4, AIR_CAST( size_t, 4 ), AIR_CAST( size_t, 12 ), sctx->sx, sctx->sy ); if ( !E ) sctx->pairs = AIR_CAST( signed char*, sctx->npairs->data ); if ( !E ) E |= nrrdMaybeAlloc_va( sctx->ngradcontext, nrrdTypeDouble, 4, AIR_CAST( size_t, 3 ), AIR_CAST( size_t, 2 ), sctx->sx, sctx->sy ); if ( !E ) sctx->gradcontext = AIR_CAST( double*, sctx->ngradcontext->data ); if ( !E ) E |= nrrdMaybeAlloc_va( sctx->nhesscontext, nrrdTypeDouble, 4, AIR_CAST( size_t, 9 ), AIR_CAST( size_t, 2 ), sctx->sx, sctx->sy ); if ( !E ) sctx->hesscontext = AIR_CAST( double*, sctx->nhesscontext->data ); if ( !E ) E |= nrrdMaybeAlloc_va( sctx->ntcontext, nrrdTypeDouble, 4, AIR_CAST( size_t, 9 ), AIR_CAST( size_t, 2 ), sctx->sx, sctx->sy ); if ( !E ) sctx->tcontext = AIR_CAST( double*, sctx->ntcontext->data ); if ( !E ) E |= nrrdMaybeAlloc_va( sctx->nstngcontext, nrrdTypeDouble, 2, sctx->sx, sctx->sy ); if ( !E ) sctx->stngcontext = AIR_CAST( double*, sctx->nstngcontext->data ); } else { sctx->facevidx = NULL; sctx->hess = NULL; sctx->t = NULL; sctx->edgealpha = NULL; sctx->edgenorm = NULL; sctx->facecoord = NULL; sctx->facenorm = NULL; sctx->pairs = NULL; sctx->gradcontext = NULL; sctx->hesscontext = NULL; sctx->tcontext = NULL; sctx->stngcontext = NULL; } sctx->flag[flagSlabCacheAlloc] = AIR_TRUE; } if ( E ) { biffMovef( SEEK, NRRD, "%s: couldn't allocate all slab caches", me ); return 1; } sctx->flag[flagStrengthUse] = AIR_FALSE; sctx->flag[flagSxSySz] = AIR_FALSE; return 0; } static int 548 updateSclDerived( seekContext *sctx ) { static const char me[]="updateSclDerived"; char doneStr[AIR_STRLEN_SMALL]; double *scl, idxIn[4], idxOut[4], val; unsigned int xi, yi, zi; if ( sctx->verbose > 5 ) { fprintf( stderr, "%s: --------------------\n", me ); fprintf( stderr, "%s: flagType = %d\n", me, sctx->flag[flagType] ); fprintf( stderr, "%s: flagNinEtAl = %d\n", me, sctx->flag[flagNinEtAl] ); } if ( sctx->flag[flagType] || sctx->flag[flagNinEtAl] ) { if ( !( seekTypeIsocontour == sctx->type && sctx->pvl ) ) { nrrdEmpty( sctx->nsclDerived ); } else { if ( nrrdMaybeAlloc_va( sctx->nsclDerived, nrrdTypeDouble, 3, sctx->sx, sctx->sy, sctx->sz ) ) { biffMovef( SEEK, NRRD, "%s: couldn't allocated derived scalar volume", me ); return 1; } scl = AIR_CAST( double*, sctx->nsclDerived->data ); if ( sctx->verbose ) { fprintf( stderr, "%s: pre-computing scalar volume ... ", me ); } for ( zi=0; zi<sctx->sz; zi++ ) { if ( sctx->verbose ) { fprintf( stderr, "%s", airDoneStr( 0, zi, sctx->sz-1, doneStr ) ); fflush( stderr ); } for ( yi=0; yi<sctx->sy; yi++ ) { for ( xi=0; xi<sctx->sx; xi++ ) { ELL_4V_SET( idxOut, xi, yi, zi, 1.0 ); ELL_4MV_MUL( idxIn, sctx->txfIdx, idxOut ); ELL_34V_HOMOG( idxIn, idxIn ); gageProbe( sctx->gctx, idxIn[0], idxIn[1], idxIn[2] ); val = sctx->sclvAns[0]; if ( !AIR_EXISTS( val ) ) { biffAddf( SEEK, "%s: probed scalar[%u, %u, %u] %g doesn't exist", me, xi, yi, zi, val ); return 1; } scl[xi + sctx->sx*( yi + sctx->sy*zi )] = val; } } } if ( sctx->verbose ) { fprintf( stderr, "%s\n", airDoneStr( 0, zi, sctx->sz-1, doneStr ) ); } } sctx->flag[flagSclDerived] = AIR_TRUE; } return 0; } static int 610 updateSpanSpaceHist( seekContext *sctx ) { static const char me[]="updateSpanSpaceHist"; unsigned int sx, sy, sz, ss, xi, yi, zi, vi, si, minI, maxI, *spanHist; double min, max, val; const void *data; double ( *lup )( const void *, size_t ); if ( sctx->verbose > 5 ) { fprintf( stderr, "%s: --------------------\n", me ); fprintf( stderr, "%s: flagType = %d\n", me, sctx->flag[flagType] ); fprintf( stderr, "%s: flagSclDerived = %d\n", me, sctx->flag[flagSclDerived] ); fprintf( stderr, "%s: flagNinEtAl = %d\n", me, sctx->flag[flagNinEtAl] ); } if ( sctx->flag[flagType] || sctx->flag[flagSclDerived] || sctx->flag[flagNinEtAl] ) { if ( seekTypeIsocontour != sctx->type ) { nrrdEmpty( sctx->nspanHist ); sctx->range->min = AIR_NAN; sctx->range->max = AIR_NAN; } else { nrrdRangeSet( sctx->range, ( sctx->ninscl ? sctx->ninscl : sctx->nsclDerived ), nrrdBlind8BitRangeFalse ); if ( sctx->range->hasNonExist ) { biffAddf( SEEK, "%s: scalar volume has non-existent values", me ); return 1; } sctx->nspanHist->axis[0].min = sctx->range->min; sctx->nspanHist->axis[1].min = sctx->range->min; sctx->nspanHist->axis[0].max = sctx->range->max; sctx->nspanHist->axis[1].max = sctx->range->max; if ( sctx->ninscl ) { lup = nrrdDLookup[sctx->ninscl->type]; data = sctx->ninscl->data; } else { lup = nrrdDLookup[sctx->nsclDerived->type]; data = sctx->nsclDerived->data; } /* calculate the span space histogram */ if ( nrrdMaybeAlloc_va( sctx->nspanHist, nrrdTypeUInt, 2, AIR_CAST( size_t, sctx->spanSize ), AIR_CAST( size_t, sctx->spanSize ) ) ) { biffMovef( SEEK, NRRD, "%s: couldn't allocate space space histogram", me ); return 1; } spanHist = AIR_CAST( unsigned int*, sctx->nspanHist->data ); sx = sctx->sx; sy = sctx->sy; sz = sctx->sz; ss = sctx->spanSize; for ( si=0; si<ss*ss; si++ ) { spanHist[si] = 0; } for ( zi=0; zi<sz-1; zi++ ) { for ( yi=0; yi<sy-1; yi++ ) { for ( xi=0; xi<sx-1; xi++ ) { vi = xi + sx*( yi + sy*zi ); val = lup( data, vi + 0 + 0*sx + 0*sx*sy ); min = max = val; val = lup( data, vi + 1 + 0*sx + 0*sx*sy ); min = AIR_MIN( min, val ); max = AIR_MAX( max, val ); val = lup( data, vi + 0 + 1*sx + 0*sx*sy ); min = AIR_MIN( min, val ); max = AIR_MAX( max, val ); val = lup( data, vi + 1 + 1*sx + 0*sx*sy ); min = AIR_MIN( min, val ); max = AIR_MAX( max, val ); val = lup( data, vi + 0 + 0*sx + 1*sx*sy ); min = AIR_MIN( min, val ); max = AIR_MAX( max, val ); val = lup( data, vi + 1 + 0*sx + 1*sx*sy ); min = AIR_MIN( min, val ); max = AIR_MAX( max, val ); val = lup( data, vi + 0 + 1*sx + 1*sx*sy ); min = AIR_MIN( min, val ); max = AIR_MAX( max, val ); val = lup( data, vi + 1 + 1*sx + 1*sx*sy ); min = AIR_MIN( min, val ); max = AIR_MAX( max, val ); minI = airIndex( sctx->range->min, min, sctx->range->max, ss ); maxI = airIndex( sctx->range->min, max, sctx->range->max, ss ); spanHist[minI + ss*maxI]++; } } } } sctx->flag[flagSclDerived] = AIR_FALSE; sctx->flag[flagSpanSpaceHist] = AIR_TRUE; } return 0; } static int 712 updateResult( seekContext *sctx ) { static const char me[]="updateResult"; if ( sctx->verbose > 5 ) { fprintf( stderr, "%s: --------------------\n", me ); fprintf( stderr, "%s: flagIsovalue = %d\n", me, sctx->flag[flagIsovalue] ); fprintf( stderr, "%s: flagAnswerPointers = %d\n", me, sctx->flag[flagAnswerPointers] ); fprintf( stderr, "%s: flagType = %d\n", me, sctx->flag[flagType] ); fprintf( stderr, "%s: flagSlabCacheAlloc = %d\n", me, sctx->flag[flagSlabCacheAlloc] ); fprintf( stderr, "%s: flagSpanSpaceHist = %d\n", me, sctx->flag[flagSpanSpaceHist] ); fprintf( stderr, "%s: flagNinEtAl = %d\n", me, sctx->flag[flagNinEtAl] ); fprintf( stderr, "%s: flagReverse = %d\n", me, sctx->flag[flagReverse] ); fprintf( stderr, "%s: flagTxfNormal = %d\n", me, sctx->flag[flagTxfNormal] ); } if ( seekTypeIsocontour != sctx->type && sctx->flag[flagIsovalue] ) { biffAddf( SEEK, "%s: can't set isovalue for %s ( only %s )", me, airEnumStr( seekType, sctx->type ), airEnumStr( seekType, seekTypeIsocontour ) ); return 1; } if ( sctx->strengthUse && !sctx->stngAns ) { biffAddf( SEEK, "%s: can't use feature strength without a strength item", me ); return 1; } /* this seems to be a very pointless exercise */ if ( sctx->flag[flagIsovalue] || sctx->flag[flagEvalDiffThresh] || sctx->flag[flagAnswerPointers] || sctx->flag[flagStrengthUse] || sctx->flag[flagStrength] || sctx->flag[flagType] || sctx->flag[flagSlabCacheAlloc] || sctx->flag[flagSpanSpaceHist] || sctx->flag[flagNinEtAl] || sctx->flag[flagReverse] || sctx->flag[flagTxfNormal] ) { sctx->flag[flagResult] = AIR_TRUE; sctx->flag[flagIsovalue] = AIR_FALSE; sctx->flag[flagEvalDiffThresh] = AIR_FALSE; sctx->flag[flagAnswerPointers] = AIR_FALSE; sctx->flag[flagStrengthUse] = AIR_FALSE; sctx->flag[flagStrength] = AIR_FALSE; sctx->flag[flagType] = AIR_FALSE; sctx->flag[flagSlabCacheAlloc] = AIR_FALSE; sctx->flag[flagSpanSpaceHist] = AIR_FALSE; sctx->flag[flagNinEtAl] = AIR_FALSE; sctx->flag[flagReverse] = AIR_FALSE; sctx->flag[flagTxfNormal] = AIR_FALSE; } return 0; } /* ******** seekUpdate ** ** traverses dependency graph for all of seek stuff, which necessarily ** includes nodes specific to, say, isosurfacing, even when isosurfacing ** is not being done. The idea is to use the same graph for all feature ** types, for error checking if nothing else, leavings steps as no-ops ** as needed. */ int 790 seekUpdate( seekContext *sctx ) { static const char me[]="seekUpdate"; int E; if ( !sctx ) { biffAddf( SEEK, "%s: got NULL pointer", me ); return 1; } E = 0; if ( !E ) E |= updateNinEtAl( sctx ); if ( !E ) E |= updateAnswerPointers( sctx ); if ( !E ) E |= updateSxSySz( sctx ); if ( !E ) E |= updateReverse( sctx ); if ( !E ) E |= updateTxfNormal( sctx ); if ( !E ) E |= updateSlabCacheAlloc( sctx ); if ( !E ) E |= updateSclDerived( sctx ); if ( !E ) E |= updateSpanSpaceHist( sctx ); if ( !E ) E |= updateResult( sctx ); if ( E ) { biffAddf( SEEK, "%s: trouble updating", me ); return 1; } return 0; }

/Users/scm/git/github/teem/src/ten/aniso.c

/* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2013, 2012, 2011, 2010, 2009 University of Chicago Copyright ( C ) 2008, 2007, 2006, 2005 Gordon Kindlmann Copyright ( C ) 2004, 2003, 2002, 2001, 2000, 1999, 1998 University of Utah This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "ten.h" #include "privateTen.h" /* ** learned: don't take sqrt( FLT_EPSILON ) and expect it to still be ** negligible */ /* ******** !!!! NOTE NOTE NOTE NOTE NOTE !!!! ******** ******** THIS CODE IS NOT REALLY MEANT TO BE EDITED BY HUMANS ******** ( only GLK : ) ******** ******** It is the worst possible example of the dangers of cut-and-paste ******** ******** !!!! NOTE NOTE NOTE NOTE NOTE !!!! */ 42 float _tenAnisoEval_Conf_f( const float eval[3] ) { AIR_UNUSED( eval ); return 1.0; } 46 double _tenAnisoEval_Conf_d( const double eval[3] ) { AIR_UNUSED( eval ); return 1.0; return 1.0; } 50 float _tenAnisoTen_Conf_f( const float ten[7] ) { return ten[0]; } 53 double _tenAnisoTen_Conf_d( const double ten[7] ) { return ten[0]; } 58 float _tenAnisoEval_Cl1_f( const float eval[3] ) { float sum = eval[0] + eval[1] + eval[2]; sum = AIR_MAX( 0, sum ); return sum ? ( eval[0] - eval[1] )/sum : 0.0f; } 63 double _tenAnisoEval_Cl1_d( const double eval[3] ) { double sum = eval[0] + eval[1] + eval[2]; sum = AIR_MAX( 0, sum ); return sum ? ( eval[0] - eval[1] )/sum : 0.0; } 68 float _tenAnisoTen_Cl1_f( const float ten[7] ) { float eval[3]; tenEigensolve_f( eval, NULL, ten ); return _tenAnisoEval_Cl1_f( eval ); } 73 double _tenAnisoTen_Cl1_d( const double ten[7] ) { double eval[3]; tenEigensolve_d( eval, NULL, ten ); return _tenAnisoEval_Cl1_d( eval ); } 80 float _tenAnisoEval_Cp1_f( const float eval[3] ) { float sum = eval[0] + eval[1] + eval[2]; sum = AIR_MAX( 0, sum ); return sum ? 2*( eval[1] - eval[2] )/sum : 0.0f; } 85 double _tenAnisoEval_Cp1_d( const double eval[3] ) { double sum = eval[0] + eval[1] + eval[2]; sum = AIR_MAX( 0, sum ); return sum ? 2*( eval[1] - eval[2] )/sum : 0.0; } 90 float _tenAnisoTen_Cp1_f( const float ten[7] ) { float eval[3]; tenEigensolve_f( eval, NULL, ten ); return _tenAnisoEval_Cp1_f( eval ); } 95 double _tenAnisoTen_Cp1_d( const double ten[7] ) { double eval[3]; tenEigensolve_d( eval, NULL, ten ); return _tenAnisoEval_Cp1_d( eval ); } 102 float _tenAnisoEval_Ca1_f( const float eval[3] ) { float sum = eval[0] + eval[1] + eval[2]; sum = AIR_MAX( 0, sum ); return sum ? ( eval[0] + eval[1] - 2*eval[2] )/sum : 0.0f; } 107 double _tenAnisoEval_Ca1_d( const double eval[3] ) { double sum = eval[0] + eval[1] + eval[2]; sum = AIR_MAX( 0, sum ); return sum ? ( eval[0] + eval[1] - 2*eval[2] )/sum : 0.0; } 112 float _tenAnisoTen_Ca1_f( const float ten[7] ) { float eval[3]; tenEigensolve_f( eval, NULL, ten ); return _tenAnisoEval_Ca1_f( eval ); } 117 double _tenAnisoTen_Ca1_d( const double ten[7] ) { double eval[3]; tenEigensolve_d( eval, NULL, ten ); return _tenAnisoEval_Ca1_d( eval ); } 124 float _tenAnisoEval_Clpmin1_f( const float eval[3] ) { float cl, cp, sum = eval[0] + eval[1] + eval[2]; sum = AIR_MAX( 0, sum ); cl = sum ? ( eval[0] - eval[1] )/sum : 0.0f; cp = sum ? 2*( eval[1] - eval[2] )/sum : 0.0f; return AIR_MIN( cl, cp ); } 131 double _tenAnisoEval_Clpmin1_d( const double eval[3] ) { double cl, cp, sum = eval[0] + eval[1] + eval[2]; sum = AIR_MAX( 0, sum ); cl = sum ? ( eval[0] - eval[1] )/sum : 0.0; cp = sum ? 2*( eval[1] - eval[2] )/sum : 0.0; return AIR_MIN( cl, cp ); } 138 float _tenAnisoTen_Clpmin1_f( const float ten[7] ) { float eval[3]; tenEigensolve_f( eval, NULL, ten ); return _tenAnisoEval_Clpmin1_f( eval ); } 143 double _tenAnisoTen_Clpmin1_d( const double ten[7] ) { double eval[3]; tenEigensolve_d( eval, NULL, ten ); return _tenAnisoEval_Clpmin1_d( eval ); } 150 float _tenAnisoEval_Cs1_f( const float eval[3] ) { float sum = eval[0] + eval[1] + eval[2]; sum = AIR_MAX( 0, sum ); return sum ? 3*eval[2]/sum : 0.0f; } 155 double _tenAnisoEval_Cs1_d( const double eval[3] ) { double sum = eval[0] + eval[1] + eval[2]; sum = AIR_MAX( 0, sum ); return sum ? 3*eval[2]/sum : 0.0; } 160 float _tenAnisoTen_Cs1_f( const float ten[7] ) { float eval[3]; tenEigensolve_f( eval, NULL, ten ); return _tenAnisoEval_Cs1_f( eval ); } 165 double _tenAnisoTen_Cs1_d( const double ten[7] ) { double eval[3]; tenEigensolve_d( eval, NULL, ten ); return _tenAnisoEval_Cs1_d( eval ); } 172 float _tenAnisoEval_Ct1_f( const float _eval[3] ) { float dem, mn, eval[3]; mn = ( _eval[0] + _eval[1] + _eval[2] )/3; ELL_3V_SET( eval, _eval[0] - mn, _eval[1] - mn, _eval[2] - mn ); dem = eval[0] + eval[1] - 2*eval[2]; return dem ? 2*( eval[1] - eval[2] )/dem : 0.0f; } 179 double _tenAnisoEval_Ct1_d( const double _eval[3] ) { double dem, mn, eval[3]; mn = ( _eval[0] + _eval[1] + _eval[2] )/3; ELL_3V_SET( eval, _eval[0] - mn, _eval[1] - mn, _eval[2] - mn ); dem = eval[0] + eval[1] - 2*eval[2]; return dem ? 2*( eval[1] - eval[2] )/dem : 0.0; } 186 float _tenAnisoTen_Ct1_f( const float ten[7] ) { float eval[3]; tenEigensolve_f( eval, NULL, ten ); return _tenAnisoEval_Ct1_f( eval ); } 191 double _tenAnisoTen_Ct1_d( const double ten[7] ) { double eval[3]; tenEigensolve_d( eval, NULL, ten ); return _tenAnisoEval_Ct1_d( eval ); } 198 float _tenAnisoEval_Cl2_f( const float eval[3] ) { float eval0 = AIR_MAX( 0, eval[0] ); return eval0 ? ( eval[0] - eval[1] )/eval0 : 0.0f; } 202 double _tenAnisoEval_Cl2_d( const double eval[3] ) { double eval0 = AIR_MAX( 0, eval[0] ); return eval0 ? ( eval[0] - eval[1] )/eval0 : 0.0; } 206 float _tenAnisoTen_Cl2_f( const float ten[7] ) { float eval[3]; tenEigensolve_f( eval, NULL, ten ); return _tenAnisoEval_Cl2_f( eval ); } 211 double _tenAnisoTen_Cl2_d( const double ten[7] ) { double eval[3]; tenEigensolve_d( eval, NULL, ten ); return _tenAnisoEval_Cl2_d( eval ); } 218 float _tenAnisoEval_Cp2_f( const float eval[3] ) { float eval0 = AIR_MAX( 0, eval[0] ); return eval0 ? ( eval[1] - eval[2] )/eval0 : 0.0f; } 222 double _tenAnisoEval_Cp2_d( const double eval[3] ) { double eval0 = AIR_MAX( 0, eval[0] ); return eval0 ? ( eval[1] - eval[2] )/eval0 : 0.0; } 226 float _tenAnisoTen_Cp2_f( const float ten[7] ) { float eval[3]; tenEigensolve_f( eval, NULL, ten ); return _tenAnisoEval_Cp2_f( eval ); } 231 double _tenAnisoTen_Cp2_d( const double ten[7] ) { double eval[3]; tenEigensolve_d( eval, NULL, ten ); return _tenAnisoEval_Cp2_d( eval ); } 238 float _tenAnisoEval_Ca2_f( const float eval[3] ) { float eval0 = AIR_MAX( 0, eval[0] ); return eval0 ? ( eval[0] - eval[2] )/eval0 : 0.0f; } 242 double _tenAnisoEval_Ca2_d( const double eval[3] ) { double eval0 = AIR_MAX( 0, eval[0] ); return eval0 ? ( eval[0] - eval[2] )/eval0 : 0.0; } 246 float _tenAnisoTen_Ca2_f( const float ten[7] ) { float eval[3]; tenEigensolve_f( eval, NULL, ten ); return _tenAnisoEval_Ca2_f( eval ); } 251 double _tenAnisoTen_Ca2_d( const double ten[7] ) { double eval[3]; tenEigensolve_d( eval, NULL, ten ); return _tenAnisoEval_Ca2_d( eval ); } 258 float _tenAnisoEval_Clpmin2_f( const float eval[3] ) { float cl, cp, eval0 = AIR_MAX( 0, eval[0] ); cl = eval0 ? ( eval[0] - eval[1] )/eval0 : 0.0f; cp = eval0 ? ( eval[1] - eval[2] )/eval0 : 0.0f; return AIR_MIN( cl, cp ); } 264 double _tenAnisoEval_Clpmin2_d( const double eval[3] ) { double cl, cp, eval0 = AIR_MAX( 0, eval[0] ); cl = eval0 ? ( eval[0] - eval[1] )/eval0 : 0.0; cp = eval0 ? ( eval[1] - eval[2] )/eval0 : 0.0; return AIR_MIN( cl, cp ); } 270 float _tenAnisoTen_Clpmin2_f( const float ten[7] ) { float eval[3]; tenEigensolve_f( eval, NULL, ten ); return _tenAnisoEval_Clpmin2_f( eval ); } 275 double _tenAnisoTen_Clpmin2_d( const double ten[7] ) { double eval[3]; tenEigensolve_d( eval, NULL, ten ); return _tenAnisoEval_Clpmin2_d( eval ); } 282 float _tenAnisoEval_Cs2_f( const float eval[3] ) { float eval0 = AIR_MAX( 0, eval[0] ); return eval0 ? eval[2]/eval0 : 0.0f; } 286 double _tenAnisoEval_Cs2_d( const double eval[3] ) { double eval0 = AIR_MAX( 0, eval[0] ); return eval0 ? eval[2]/eval0 : 0.0; } 290 float _tenAnisoTen_Cs2_f( const float ten[7] ) { float eval[3]; tenEigensolve_f( eval, NULL, ten ); return _tenAnisoEval_Cs2_f( eval ); } 295 double _tenAnisoTen_Cs2_d( const double ten[7] ) { double eval[3]; tenEigensolve_d( eval, NULL, ten ); return _tenAnisoEval_Cs2_d( eval ); } 302 float _tenAnisoEval_Ct2_f( const float eval[3] ) { float denom; denom = eval[0] - eval[2]; return denom ? ( eval[1] - eval[2] )/denom : 0.0f; } 307 double _tenAnisoEval_Ct2_d( const double eval[3] ) { double denom; denom = eval[0] - eval[2]; return denom ? ( eval[1] - eval[2] )/denom : 0.0; } 312 float _tenAnisoTen_Ct2_f( const float ten[7] ) { float eval[3]; tenEigensolve_f( eval, NULL, ten ); return _tenAnisoEval_Ct2_f( eval ); } 317 double _tenAnisoTen_Ct2_d( const double ten[7] ) { double eval[3]; tenEigensolve_d( eval, NULL, ten ); return _tenAnisoEval_Ct2_d( eval ); } #define SQRT6 2.44948974278317809819 325 float _tenAnisoEval_RA_f( const float eval[3] ) { float mean, stdv; mean = ( eval[0] + eval[1] + eval[2] )/3; stdv = AIR_CAST( float, sqrt( ( mean-eval[0] )*( mean-eval[0] ) /* not exactly stdv */ + ( mean-eval[1] )*( mean-eval[1] ) + ( mean-eval[2] )*( mean-eval[2] ) ) ); return mean ? AIR_CAST( float, stdv/( mean*SQRT6 ) ) : 0.0f; } 334 double _tenAnisoEval_RA_d( const double eval[3] ) { double mean, stdv; mean = ( eval[0] + eval[1] + eval[2] )/3; stdv = sqrt( ( mean-eval[0] )*( mean-eval[0] ) /* not exactly standard dev */ + ( mean-eval[1] )*( mean-eval[1] ) + ( mean-eval[2] )*( mean-eval[2] ) ); return mean ? stdv/( mean*SQRT6 ) : 0.0; } 342 float _tenAnisoTen_RA_f( const float tt[7] ) { float mn, stdv, dev[7]; mn = TEN_T_TRACE( tt )/3; TEN_T_SET( dev, tt[0], tt[1]-mn, tt[2], tt[3], tt[4]-mn, tt[5], tt[6]-mn ); stdv = AIR_CAST( float, sqrt( TEN_T_DOT( dev, dev ) ) ); return mn ? AIR_CAST( float, stdv/( mn*SQRT6 ) ) : 0.0f; } 349 double _tenAnisoTen_RA_d( const double tt[7] ) { double mn, stdv, dev[7]; mn = TEN_T_TRACE( tt )/3; TEN_T_SET( dev, tt[0], tt[1]-mn, tt[2], tt[3], tt[4]-mn, tt[5], tt[6]-mn ); stdv = sqrt( TEN_T_DOT( dev, dev ) ); return mn ? stdv/( mn*SQRT6 ) : 0.0; } 358 float _tenAnisoEval_FA_f( const float eval[3] ) { float denom, mean, stdv; denom = 2.0f*( eval[0]*eval[0] + eval[1]*eval[1] + eval[2]*eval[2] ); mean = ( eval[0] + eval[1] + eval[2] )/3; stdv = AIR_CAST( float, ( mean-eval[0] )*( mean-eval[0] ) /* not exactly stdv */ + ( mean-eval[1] )*( mean-eval[1] ) + ( mean-eval[2] )*( mean-eval[2] ) ); return denom ? AIR_CAST( float, sqrt( 3.0*stdv/denom ) ) : 0.0f; } 368 double _tenAnisoEval_FA_d( const double eval[3] ) { double denom, mean, stdv; denom = 2.0*( eval[0]*eval[0] + eval[1]*eval[1] + eval[2]*eval[2] ); mean = ( eval[0] + eval[1] + eval[2] )/3; stdv = ( ( mean-eval[0] )*( mean-eval[0] ) /* not exactly standard dev */ + ( mean-eval[1] )*( mean-eval[1] ) + ( mean-eval[2] )*( mean-eval[2] ) ); return denom ? sqrt( 3.0*stdv/denom ) : 0.0; } 377 float _tenAnisoTen_FA_f( const float tt[7] ) { float denom, mn, stdv, dev[7]; denom = AIR_CAST( float, 2.0*TEN_T_DOT( tt, tt ) ); mn = TEN_T_TRACE( tt )/3; TEN_T_SET( dev, tt[0], tt[1]-mn, tt[2], tt[3], tt[4]-mn, tt[5], tt[6]-mn ); stdv = TEN_T_DOT( dev, dev ); return denom ? AIR_CAST( float, sqrt( 3.0*stdv/denom ) ) : 0.0f; } 385 double _tenAnisoTen_FA_d( const double tt[7] ) { double denom, mn, stdv, dev[7]; denom = 2.0*TEN_T_DOT( tt, tt ); mn = TEN_T_TRACE( tt )/3; TEN_T_SET( dev, tt[0], tt[1]-mn, tt[2], tt[3], tt[4]-mn, tt[5], tt[6]-mn ); stdv = TEN_T_DOT( dev, dev ); return denom ? AIR_CAST( float, sqrt( 3.0*stdv/denom ) ) : 0.0; } 395 float _tenAnisoEval_VF_f( const float eval[3] ) { float mean; mean = ( eval[0] + eval[1] + eval[2] )/3.0f; mean = mean*mean*mean; return 1.0f - ( mean ? eval[0]*eval[1]*eval[2]/mean : 0.0f ); } 401 double _tenAnisoEval_VF_d( const double eval[3] ) { double mean; mean = ( eval[0] + eval[1] + eval[2] )/3; mean = mean*mean*mean; return 1.0 - ( mean ? eval[0]*eval[1]*eval[2]/mean : 0.0 ); } 407 float _tenAnisoTen_VF_f( const float ten[7] ) { float mean; mean = TEN_T_TRACE( ten )/3.0f; mean = mean*mean*mean; return 1.0f - ( mean ? TEN_T_DET( ten )/mean : 0.0f ); } 413 double _tenAnisoTen_VF_d( const double ten[7] ) { double mean; mean = TEN_T_TRACE( ten )/3.0; mean = mean*mean*mean; return 1.0 - ( mean ? TEN_T_DET( ten )/mean : 0.0 ); } 421 float _tenAnisoEval_B_f( const float eval[3] ) { return eval[0]*eval[1] + eval[0]*eval[2] + eval[1]*eval[2]; } 424 double _tenAnisoEval_B_d( const double eval[3] ) { return eval[0]*eval[1] + eval[0]*eval[2] + eval[1]*eval[2]; } 427 float _tenAnisoTen_B_f( const float ten[7] ) { return ( ten[1]*ten[4] + ten[1]*ten[6] + ten[4]*ten[6] - ten[2]*ten[2] - ten[3]*ten[3] - ten[5]*ten[5] ); } 431 double _tenAnisoTen_B_d( const double ten[7] ) { return ( ten[1]*ten[4] + ten[1]*ten[6] + ten[4]*ten[6] - ten[2]*ten[2] - ten[3]*ten[3] - ten[5]*ten[5] ); } 437 float _tenAnisoEval_Q_f( const float eval[3] ) { float A, B; A = -( eval[0] + eval[1] + eval[2] ); B = _tenAnisoEval_B_f( eval ); A = ( A*A - 3.0f*B )/9.0f; return AIR_MAX( 0, A ); } 444 double _tenAnisoEval_Q_d( const double eval[3] ) { double A, B; A = -( eval[0] + eval[1] + eval[2] ); B = _tenAnisoEval_B_d( eval ); A = ( A*A - 3.0*B )/9.0; return AIR_MAX( 0, A ); } 451 float _tenAnisoTen_Q_f( const float ten[7] ) { float A, B; A = -TEN_T_TRACE( ten ); B = _tenAnisoTen_B_f( ten ); A = ( A*A - 3.0f*B )/9.0f; return AIR_MAX( 0, A ); } 458 double _tenAnisoTen_Q_d( const double ten[7] ) { double A, B; A = -TEN_T_TRACE( ten ); B = _tenAnisoTen_B_d( ten ); A = ( A*A - 3.0*B )/9.0; return AIR_MAX( 0, A ); } 467 float _tenAnisoEval_R_f( const float eval[3] ) { float A, B, C; A = -( eval[0] + eval[1] + eval[2] ); B = _tenAnisoEval_B_f( eval ); C = -eval[0]*eval[1]*eval[2]; return ( -2*A*A*A + 9*A*B - 27*C )/54; } 474 double _tenAnisoEval_R_d( const double eval[3] ) { double A, B, C; A = -( eval[0] + eval[1] + eval[2] ); B = _tenAnisoEval_B_d( eval ); C = -eval[0]*eval[1]*eval[2]; return ( -2*A*A*A + 9*A*B - 27*C )/54; } 481 float _tenAnisoTen_R_f( const float ten[7] ) { float A, B, C; A = -TEN_T_TRACE( ten ); B = _tenAnisoTen_B_f( ten ); C = -TEN_T_DET( ten ); return ( -2*A*A*A + 9*A*B - 27*C )/54; } 488 double _tenAnisoTen_R_d( const double ten[7] ) { double A, B, C; A = -TEN_T_TRACE( ten ); B = _tenAnisoTen_B_d( ten ); C = -TEN_T_DET( ten ); return ( -2*A*A*A + 9*A*B - 27*C )/54; } 497 float _tenAnisoEval_S_f( const float eval[3] ) { return eval[0]*eval[0] + eval[1]*eval[1] + eval[2]*eval[2]; } 500 double _tenAnisoEval_S_d( const double eval[3] ) { return eval[0]*eval[0] + eval[1]*eval[1] + eval[2]*eval[2]; } 503 float _tenAnisoTen_S_f( const float ten[7] ) { return TEN_T_DOT( ten, ten ); } 506 double _tenAnisoTen_S_d( const double ten[7] ) { return TEN_T_DOT( ten, ten ); } #define OOSQRT2 0.70710678118654752440 511 float _tenAnisoEval_Skew_f( const float _eval[3] ) { float Q, num, dnm, ret, mn, eval[3]; mn = ( _eval[0] + _eval[1] + _eval[2] )/3; ELL_3V_SET( eval, _eval[0] - mn, _eval[1] - mn, _eval[2] - mn ); Q = _tenAnisoEval_Q_f( eval ); num = _tenAnisoEval_R_f( eval ); dnm = AIR_CAST( float, Q*sqrt( 2*Q ) ); ret = dnm ? AIR_CAST( float, num/dnm ) : 0.0f; return AIR_CAST( float, AIR_CLAMP( -OOSQRT2, ret, OOSQRT2 ) ); } 521 double _tenAnisoEval_Skew_d( const double _eval[3] ) { double Q, num, dnm, ret, mn, eval[3]; mn = ( _eval[0] + _eval[1] + _eval[2] )/3; ELL_3V_SET( eval, _eval[0] - mn, _eval[1] - mn, _eval[2] - mn ); Q = _tenAnisoEval_Q_d( eval ); num = _tenAnisoEval_R_d( eval ); dnm = Q*sqrt( 2*Q ); ret = dnm ? num/dnm : 0.0; return AIR_CLAMP( -OOSQRT2, ret, OOSQRT2 ); } 531 float _tenAnisoTen_Skew_f( const float _t[7] ) { float Q, num, dnm, ret, mn, ten[7]; mn = TEN_T_TRACE( _t )/3; TEN_T_SET( ten, _t[0], _t[1]-mn, _t[2], _t[3], _t[4]-mn, _t[5], _t[6]-mn ); Q = _tenAnisoTen_Q_f( ten ); num = _tenAnisoTen_R_f( ten ); dnm = AIR_CAST( float, Q*sqrt( 2*Q ) ); ret = dnm ? AIR_CAST( float, num/dnm ) : 0.0f; return AIR_CAST( float, AIR_CLAMP( -OOSQRT2, ret, OOSQRT2 ) ); } 541 double _tenAnisoTen_Skew_d( const double _t[7] ) { double Q, num, dnm, ret, mn, ten[7]; mn = TEN_T_TRACE( _t )/3; TEN_T_SET( ten, _t[0], _t[1]-mn, _t[2], _t[3], _t[4]-mn, _t[5], _t[6]-mn ); Q = _tenAnisoTen_Q_d( ten ); num = _tenAnisoTen_R_d( ten ); dnm = Q*sqrt( 2*Q ); ret = dnm ? num/dnm : 0.0; return AIR_CLAMP( -OOSQRT2, ret, OOSQRT2 ); } 553 float _tenAnisoEval_Mode_f( const float _eval[3] ) { float n, d, mn, e[3], ret; mn = ( _eval[0] + _eval[1] + _eval[2] )/3; ELL_3V_SET( e, _eval[0] - mn, _eval[1] - mn, _eval[2] - mn ); n = ( e[0] + e[1] - 2*e[2] )*( 2*e[0] - e[1] - e[2] )*( e[0] - 2*e[1] + e[2] ); d = ( e[0]*e[0] + e[1]*e[1] + e[2]*e[2] - e[0]*e[1] - e[1]*e[2] - e[0]*e[2] ); d = AIR_CAST( float, sqrt( AIR_MAX( 0, d ) ) ); d = 2*d*d*d; ret = d ? AIR_CAST( float, n/d ) : 0.0f; return AIR_CLAMP( -1, ret, 1 ); } 565 double _tenAnisoEval_Mode_d( const double _eval[3] ) { double n, d, mn, e[3], ret; mn = ( _eval[0] + _eval[1] + _eval[2] )/3; ELL_3V_SET( e, _eval[0] - mn, _eval[1] - mn, _eval[2] - mn ); n = ( e[0] + e[1] - 2*e[2] )*( 2*e[0] - e[1] - e[2] )*( e[0] - 2*e[1] + e[2] ); d = ( e[0]*e[0] + e[1]*e[1] + e[2]*e[2] - e[0]*e[1] - e[1]*e[2] - e[0]*e[2] ); d = sqrt( AIR_MAX( 0, d ) ); d = 2*d*d*d; ret = d ? n/d : 0.0; return AIR_CLAMP( -1, ret, 1 ); } 577 float _tenAnisoTen_Mode_f( const float tt[7] ) { float mn, dev[7], tmp, ret; mn = TEN_T_TRACE( tt )/3.0f; TEN_T_SET( dev, tt[0], tt[1]-mn, tt[2], tt[3], tt[4]-mn, tt[5], tt[6]-mn ); tmp = AIR_CAST( float, TEN_T_NORM( dev ) ); tmp = tmp ? 1.0f/tmp : 0.0f; TEN_T_SCALE( dev, tmp, dev ); ret = AIR_CAST( float, 3*SQRT6*TEN_T_DET( dev ) ); return AIR_CLAMP( -1, ret, 1 ); } 587 double _tenAnisoTen_Mode_d( const double tt[7] ) { double mn, dev[7], tmp, ret; mn = TEN_T_TRACE( tt )/3.0; TEN_T_SET( dev, tt[0], tt[1]-mn, tt[2], tt[3], tt[4]-mn, tt[5], tt[6]-mn ); tmp = TEN_T_NORM( dev ); tmp = tmp ? 1.0/tmp : 0.0; TEN_T_SCALE( dev, tmp, dev ); ret = 3*SQRT6*TEN_T_DET( dev ); return AIR_CLAMP( -1, ret, 1 ); } /* NOTE: yes, the AIR_CLAMPs here are needed even though ** the _Skew_ functions clamp their output */ #define SQRT2 1.41421356237309504880 602 float _tenAnisoEval_Th_f( const float eval[3] ) { float tmp; tmp = AIR_CAST( float, SQRT2*_tenAnisoEval_Skew_f( eval ) ); return AIR_CAST( float, acos( AIR_CLAMP( -1, tmp, 1 ) )/3 ); } 607 double _tenAnisoEval_Th_d( const double eval[3] ) { double tmp; tmp = SQRT2*_tenAnisoEval_Skew_d( eval ); return acos( AIR_CLAMP( -1, tmp, 1 ) )/3; } 612 float _tenAnisoTen_Th_f( const float ten[7] ) { float tmp; tmp = AIR_CAST( float, SQRT2*_tenAnisoTen_Skew_f( ten ) ); return AIR_CAST( float, acos( AIR_CLAMP( -1, tmp, 1 ) )/3 ); } 617 double _tenAnisoTen_Th_d( const double ten[7] ) { double tmp; tmp = SQRT2*_tenAnisoTen_Skew_d( ten ); return acos( AIR_CLAMP( -1, tmp, 1 ) )/3; } 624 float _tenAnisoEval_Omega_f( const float eval[3] ) { return _tenAnisoEval_FA_f( eval )*( 1.0f+_tenAnisoEval_Mode_f( eval ) )/2.0f; } 627 double _tenAnisoEval_Omega_d( const double eval[3] ) { return _tenAnisoEval_FA_d( eval )*( 1.0f+_tenAnisoEval_Mode_d( eval ) )/2.0f; } 630 float _tenAnisoTen_Omega_f( const float ten[7] ) { return _tenAnisoTen_FA_f( ten )*( 1.0f+_tenAnisoTen_Mode_f( ten ) )/2.0f; } 633 double _tenAnisoTen_Omega_d( const double ten[7] ) { return _tenAnisoTen_FA_d( ten )*( 1.0f+_tenAnisoTen_Mode_d( ten ) )/2.0f; } 638 float _tenAnisoEval_Det_f( const float eval[3] ) { return eval[0]*eval[1]*eval[2]; } 641 double _tenAnisoEval_Det_d( const double eval[3] ) { return eval[0]*eval[1]*eval[2]; } 644 float _tenAnisoTen_Det_f( const float ten[7] ) { return TEN_T_DET( ten ); } 647 double _tenAnisoTen_Det_d( const double ten[7] ) { return TEN_T_DET( ten ); } 652 float _tenAnisoEval_Tr_f( const float eval[3] ) { return eval[0] + eval[1] + eval[2]; } 655 double _tenAnisoEval_Tr_d( const double eval[3] ) { return eval[0] + eval[1] + eval[2]; } 658 float _tenAnisoTen_Tr_f( const float ten[7] ) { return TEN_T_TRACE( ten ); } 661 double _tenAnisoTen_Tr_d( const double ten[7] ) { return TEN_T_TRACE( ten ); } 666 float _tenAnisoEval_eval0_f( const float eval[3] ) { return eval[0]; } 667 double _tenAnisoEval_eval0_d( const double eval[3] ) { return eval[0]; } 668 float _tenAnisoTen_eval0_f( const float ten[7] ) { float eval[3]; tenEigensolve_f( eval, NULL, ten ); return eval[0]; } 673 double _tenAnisoTen_eval0_d( const double ten[7] ) { double eval[3]; tenEigensolve_d( eval, NULL, ten ); return eval[0]; } 679 float _tenAnisoEval_eval1_f( const float eval[3] ) { return eval[1]; } 680 double _tenAnisoEval_eval1_d( const double eval[3] ) { return eval[1]; } 681 float _tenAnisoTen_eval1_f( const float ten[7] ) { float eval[3]; tenEigensolve_f( eval, NULL, ten ); return eval[1]; } 686 double _tenAnisoTen_eval1_d( const double ten[7] ) { double eval[3]; tenEigensolve_d( eval, NULL, ten ); return eval[1]; } 693 float _tenAnisoEval_eval2_f( const float eval[3] ) { return eval[2]; } 694 double _tenAnisoEval_eval2_d( const double eval[3] ) { return eval[2]; } 695 float _tenAnisoTen_eval2_f( const float ten[7] ) { float eval[3]; tenEigensolve_f( eval, NULL, ten ); return eval[2]; } 700 double _tenAnisoTen_eval2_d( const double ten[7] ) { double eval[3]; tenEigensolve_d( eval, NULL, ten ); return eval[2]; } 707 float ( *_tenAnisoEval_f[TEN_ANISO_MAX+1] )( const float eval[3] ) = { NULL, _tenAnisoEval_Conf_f, _tenAnisoEval_Cl1_f, _tenAnisoEval_Cp1_f, _tenAnisoEval_Ca1_f, _tenAnisoEval_Clpmin1_f, _tenAnisoEval_Cs1_f, _tenAnisoEval_Ct1_f, _tenAnisoEval_Cl2_f, _tenAnisoEval_Cp2_f, _tenAnisoEval_Ca2_f, _tenAnisoEval_Clpmin2_f, _tenAnisoEval_Cs2_f, _tenAnisoEval_Ct2_f, _tenAnisoEval_RA_f, _tenAnisoEval_FA_f, _tenAnisoEval_VF_f, _tenAnisoEval_B_f, _tenAnisoEval_Q_f, _tenAnisoEval_R_f, _tenAnisoEval_S_f, _tenAnisoEval_Skew_f, _tenAnisoEval_Mode_f, _tenAnisoEval_Th_f, _tenAnisoEval_Omega_f, _tenAnisoEval_Det_f, _tenAnisoEval_Tr_f, _tenAnisoEval_eval0_f, _tenAnisoEval_eval1_f, _tenAnisoEval_eval2_f }; 740 double ( *_tenAnisoEval_d[TEN_ANISO_MAX+1] )( const double eval[3] ) = { NULL, _tenAnisoEval_Conf_d, _tenAnisoEval_Cl1_d, _tenAnisoEval_Cp1_d, _tenAnisoEval_Ca1_d, _tenAnisoEval_Clpmin1_d, _tenAnisoEval_Cs1_d, _tenAnisoEval_Ct1_d, _tenAnisoEval_Cl2_d, _tenAnisoEval_Cp2_d, _tenAnisoEval_Ca2_d, _tenAnisoEval_Clpmin2_d, _tenAnisoEval_Cs2_d, _tenAnisoEval_Ct2_d, _tenAnisoEval_RA_d, _tenAnisoEval_FA_d, _tenAnisoEval_VF_d, _tenAnisoEval_B_d, _tenAnisoEval_Q_d, _tenAnisoEval_R_d, _tenAnisoEval_S_d, _tenAnisoEval_Skew_d, _tenAnisoEval_Mode_d, _tenAnisoEval_Th_d, _tenAnisoEval_Omega_d, _tenAnisoEval_Det_d, _tenAnisoEval_Tr_d, _tenAnisoEval_eval0_d, _tenAnisoEval_eval1_d, _tenAnisoEval_eval2_d }; float ( *_tenAnisoTen_f[TEN_ANISO_MAX+1] )( const float ten[7] ) = { NULL, _tenAnisoTen_Conf_f, _tenAnisoTen_Cl1_f, _tenAnisoTen_Cp1_f, _tenAnisoTen_Ca1_f, _tenAnisoTen_Clpmin1_f, _tenAnisoTen_Cs1_f, _tenAnisoTen_Ct1_f, _tenAnisoTen_Cl2_f, _tenAnisoTen_Cp2_f, _tenAnisoTen_Ca2_f, _tenAnisoTen_Clpmin2_f, _tenAnisoTen_Cs2_f, _tenAnisoTen_Ct2_f, _tenAnisoTen_RA_f, _tenAnisoTen_FA_f, _tenAnisoTen_VF_f, _tenAnisoTen_B_f, _tenAnisoTen_Q_f, _tenAnisoTen_R_f, _tenAnisoTen_S_f, _tenAnisoTen_Skew_f, _tenAnisoTen_Mode_f, _tenAnisoTen_Th_f, _tenAnisoTen_Omega_f, _tenAnisoTen_Det_f, _tenAnisoTen_Tr_f, _tenAnisoTen_eval0_f, _tenAnisoTen_eval1_f, _tenAnisoTen_eval2_f }; double ( *_tenAnisoTen_d[TEN_ANISO_MAX+1] )( const double ten[7] ) = { NULL, _tenAnisoTen_Conf_d, _tenAnisoTen_Cl1_d, _tenAnisoTen_Cp1_d, _tenAnisoTen_Ca1_d, _tenAnisoTen_Clpmin1_d, _tenAnisoTen_Cs1_d, _tenAnisoTen_Ct1_d, _tenAnisoTen_Cl2_d, _tenAnisoTen_Cp2_d, _tenAnisoTen_Ca2_d, _tenAnisoTen_Clpmin2_d, _tenAnisoTen_Cs2_d, _tenAnisoTen_Ct2_d, _tenAnisoTen_RA_d, _tenAnisoTen_FA_d, _tenAnisoTen_VF_d, _tenAnisoTen_B_d, _tenAnisoTen_Q_d, _tenAnisoTen_R_d, _tenAnisoTen_S_d, _tenAnisoTen_Skew_d, _tenAnisoTen_Mode_d, _tenAnisoTen_Th_d, _tenAnisoTen_Omega_d, _tenAnisoTen_Det_d, _tenAnisoTen_Tr_d, _tenAnisoTen_eval0_d, _tenAnisoTen_eval1_d, _tenAnisoTen_eval2_d }; float tenAnisoEval_f( const float eval[3], int aniso ) { return ( AIR_IN_OP( tenAnisoUnknown, aniso, tenAnisoLast ) ? _tenAnisoEval_f[aniso]( eval ) : 0 ); } double tenAnisoEval_d( const double eval[3], int aniso ) { return ( AIR_IN_OP( tenAnisoUnknown, aniso, tenAnisoLast ) ? _tenAnisoEval_d[aniso]( eval ) : 0 ); } float tenAnisoTen_f( const float ten[7], int aniso ) { return ( AIR_IN_OP( tenAnisoUnknown, aniso, tenAnisoLast ) ? _tenAnisoTen_f[aniso]( ten ) : 0 ); } double tenAnisoTen_d( const double ten[7], int aniso ) { return ( AIR_IN_OP( tenAnisoUnknown, aniso, tenAnisoLast ) ? _tenAnisoTen_d[aniso]( ten ) : 0 ); } #if 0 /* ******** tenAnisoCalc_f ** ** !!! THIS FUNCTION HAS BEEN MADE OBSOLETE BY THE NEW ** !!! tenAnisoEval_{f, d} AND tenAnisoTen_{f, d} FUNCTIONS ** !!! THIS WILL LIKELY BE REMOVED FROM FUTURE RELEASES ** ** Because this function does not subtract out the eigenvalue mean ** when computing quantities like Skew and Mode, it has really lousy ** accuracy on those measures compared to tenAnisoEval_{f, d}. ** ** given an array of three SORTED ( descending ) eigenvalues "e", ** calculates the anisotropy coefficients of Westin et al., ** as well as various others. ** ** NOTE: with time, so many metrics have ended up here that under ** no cases should this be used in any kind of time-critical operations ** ** This does NOT use biff. */ void tenAnisoCalc_f( float c[TEN_ANISO_MAX+1], const float e[3] ) { float e0, e1, e2, stdv, mean, sum, cl, cp, ca, ra, fa, vf, denom; float A, B, C, R, Q, N, D; if ( !( e[0] >= e[1] && e[1] >= e[2] ) ) { fprintf( stderr, "tenAnisoCalc_f: eigen values not sorted: " "%g %g %g ( %d %d )\n", e[0], e[1], e[2], e[0] >= e[1], e[1] >= e[2] ); } if ( ( tenVerbose > 1 ) && !( e[0] >= 0 && e[1] >= 0 && e[2] >= 0 ) ) { fprintf( stderr, "tenAnisoCalc_f: eigen values not all >= 0: %g %g %g\n", e[0], e[1], e[2] ); } e0 = AIR_MAX( e[0], 0 ); e1 = AIR_MAX( e[1], 0 ); e2 = AIR_MAX( e[2], 0 ); sum = e0 + e1 + e2; /* first version of cl, cp, cs */ cl = sum ? ( e0 - e1 )/sum : 0.0f; c[tenAniso_Cl1] = cl; cp = sum ? 2*( e1 - e2 )/sum : 0.0f; c[tenAniso_Cp1] = cp; ca = cl + cp; c[tenAniso_Ca1] = ca; c[tenAniso_Clpmin1] = AIR_MIN( cl, cp ); /* extra logic here for equality with expressions above */ c[tenAniso_Cs1] = sum ? 1 - ca : 0.0f; c[tenAniso_Ct1] = ca ? cp/ca : 0; /* second version of cl, cp, cs */ cl = e0 ? ( e0 - e1 )/e0 : 0.0f; c[tenAniso_Cl2] = cl; cp = e0 ? ( e1 - e2 )/e0 : 0.0f; c[tenAniso_Cp2] = cp; ca = cl + cp; c[tenAniso_Ca2] = ca; c[tenAniso_Clpmin2] = AIR_MIN( cl, cp ); /* extra logic here for equality with expressions above */ c[tenAniso_Cs2] = e0 ? 1 - ca : 0.0f; c[tenAniso_Ct2] = ca ? cp/ca : 0.0f; /* non-westin anisos */ mean = sum/3.0f; stdv = AIR_CAST( float, sqrt( ( mean-e0 )*( mean-e0 ) /* okay, not exactly standard dev */ + ( mean-e1 )*( mean-e1 ) + ( mean-e2 )*( mean-e2 ) ) ); ra = mean ? AIR_CAST( float, stdv/( mean*SQRT6 ) ) : 0.0f; ra = AIR_CLAMP( 0.0f, ra, 1.0f ); c[tenAniso_RA] = ra; denom = 2.0f*( e0*e0 + e1*e1 + e2*e2 ); if ( denom ) { fa = AIR_CAST( float, stdv*sqrt( 3.0/denom ) ); fa = AIR_CLAMP( 0.0f, fa, 1.0f ); } else { fa = 0.0f; } c[tenAniso_FA] = fa; vf = 1 - ( mean ? e0*e1*e2/( mean*mean*mean ) : 0.0f ); vf = AIR_CLAMP( 0.0f, vf, 1.0f ); c[tenAniso_VF] = vf; A = ( -e0 - e1 - e2 ); B = c[tenAniso_B] = e0*e1 + e0*e2 + e1*e2; C = -e0*e1*e2; Q = c[tenAniso_Q] = ( A*A - 3*B )/9; R = c[tenAniso_R] = ( -2*A*A*A + 9*A*B - 27*C )/54; c[tenAniso_S] = e0*e0 + e1*e1 + e2*e2; c[tenAniso_Skew] = Q ? AIR_CAST( float, R/( Q*sqrt( 2*Q ) ) ) : 0.0f; c[tenAniso_Skew] = AIR_CLAMP( -OOSQRT2, c[tenAniso_Skew], OOSQRT2 ); N = ( e0 + e1 - 2*e2 )*( 2*e0 - e1 - e2 )*( e0 - 2*e1 + e2 ); D = AIR_CAST( float, sqrt( e0*e0+e1*e1+e2*e2 - e0*e1-e1*e2-e0*e2 ) ); c[tenAniso_Mode] = D ? N/( 2*D*D*D ) : 0.0f; c[tenAniso_Mode] = AIR_CLAMP( -1, c[tenAniso_Mode], 1 ); c[tenAniso_Th] = AIR_CAST( float, acos( AIR_CLAMP( -1, sqrt( 2 )*c[tenAniso_Skew], 1 ) )/3 ); c[tenAniso_Omega] = c[tenAniso_FA]*( 1+c[tenAniso_Mode] )/2; c[tenAniso_Det] = e0*e1*e2; c[tenAniso_Tr] = e0 + e1 + e2; c[tenAniso_eval0] = e0; c[tenAniso_eval1] = e1; c[tenAniso_eval2] = e2; return; } #endif int tenAnisoPlot( Nrrd *nout, int aniso, unsigned int res, int hflip, int whole, int nanout ) { static const char me[]="tenAnisoMap"; float *out, tmp; unsigned int x, y; float m0[3], m1[3], m2[3], c0, c1, c2, e[3]; float S = 1/3.0f, L = 1.0f, P = 1/2.0f; /* these make Westin's original ( cl, cp, cs ) align with the barycentric coordinates */ if ( airEnumValCheck( tenAniso, aniso ) ) { biffAddf( TEN, "%s: invalid aniso ( %d )", me, aniso ); return 1; } if ( !( res > 2 ) ) { biffAddf( TEN, "%s: resolution ( %d ) invalid", me, res ); return 1; } if ( nrrdMaybeAlloc_va( nout, nrrdTypeFloat, 2, AIR_CAST( size_t, res ), AIR_CAST( size_t, res ) ) ) { biffMovef( TEN, NRRD, "%s: ", me ); return 1; } out = ( float * )nout->data; if ( whole ) { ELL_3V_SET( m0, 1, 0, 0 ); ELL_3V_SET( m1, 0, 1, 0 ); ELL_3V_SET( m2, 0, 0, 1 ); } else { ELL_3V_SET( m0, S, S, S ); if ( hflip ) { ELL_3V_SET( m1, P, P, 0 ); ELL_3V_SET( m2, L, 0, 0 ); } else { ELL_3V_SET( m1, L, 0, 0 ); ELL_3V_SET( m2, P, P, 0 ); } } for ( y=0; y<res; y++ ) { for ( x=0; x<=y; x++ ) { /* ( c0, c1, c2 ) are the barycentric coordinates */ c0 = AIR_CAST( float, 1.0 - AIR_AFFINE( -0.5, y, res-0.5, 0.0, 1.0 ) ); c2 = AIR_CAST( float, AIR_AFFINE( -0.5, x, res-0.5, 0.0, 1.0 ) ); c1 = 1 - c0 - c2; e[0] = c0*m0[0] + c1*m1[0] + c2*m2[0]; e[1] = c0*m0[1] + c1*m1[1] + c2*m2[1]; e[2] = c0*m0[2] + c1*m1[2] + c2*m2[2]; ELL_SORT3( e[0], e[1], e[2], tmp ); /* got some warnings w/out this */ out[x + res*y] = tenAnisoEval_f( e, aniso ); } if ( nanout ) { for ( x=y+1; x<res; x++ ) { out[x + res*y] = AIR_NAN; } } } return 0; } int tenAnisoVolume( Nrrd *nout, const Nrrd *nin, int aniso, double confThresh ) { static const char me[]="tenAnisoVolume"; size_t N, I; float *out, *in, *tensor; int map[NRRD_DIM_MAX]; size_t sx, sy, sz, size[3]; if ( tenTensorCheck( nin, nrrdTypeFloat, AIR_TRUE, AIR_TRUE ) ) { biffAddf( TEN, "%s: didn't get a tensor nrrd", me ); return 1; } if ( airEnumValCheck( tenAniso, aniso ) ) { biffAddf( TEN, "%s: invalid aniso ( %d )", me, aniso ); return 1; } confThresh = AIR_CLAMP( 0.0, confThresh, 1.0 ); size[0] = sx = nin->axis[1].size; size[1] = sy = nin->axis[2].size; size[2] = sz = nin->axis[3].size; N = sx*sy*sz; if ( nrrdMaybeAlloc_va( nout, nrrdTypeFloat, 3, sx, sy, sz ) ) { biffMovef( TEN, NRRD, "%s: trouble", me ); return 1; } out = ( float * )nout->data; in = ( float * )nin->data; for ( I=0; I<=N-1; I++ ) { /* tenVerbose = ( I == 911327 ); */ tensor = in + I*7; if ( tenAniso_Conf != aniso && tensor[0] < confThresh ) { out[I] = 0.0; continue; } /* no longer used tenEigensolve_f( eval, NULL, tensor ); if ( !( AIR_EXISTS( eval[0] ) && AIR_EXISTS( eval[1] ) && AIR_EXISTS( eval[2] ) ) ) { NRRD_COORD_GEN( coord, size, 3, I ); biffAddf( TEN, "%s: not all eigenvalues exist ( %g, %g, %g ) at sample " "%d = ( %d, %d, %d )", me, eval[0], eval[1], eval[2], ( int )I, ( int )coord[0], ( int )coord[1], ( int )coord[2] ); return 1; } */ out[I] = tenAnisoTen_f( tensor, aniso ); if ( !AIR_EXISTS( out[I] ) ) { size_t coord[3]; NRRD_COORD_GEN( coord, size, 3, I ); biffAddf( TEN, "%s: generated non-existent aniso %g from tensor " "( %g ) %g %g %g %g %g %g at sample %u = ( %u, %u, %u )", me, out[I], tensor[0], tensor[1], tensor[2], tensor[3], tensor[4], tensor[5], tensor[6], AIR_CAST( unsigned int, I ), AIR_CAST( unsigned int, coord[0] ), AIR_CAST( unsigned int, coord[1] ), AIR_CAST( unsigned int, coord[2] ) ); return 1; } } ELL_3V_SET( map, 1, 2, 3 ); if ( nrrdAxisInfoCopy( nout, nin, map, NRRD_AXIS_INFO_SIZE_BIT ) ) { biffMovef( TEN, NRRD, "%s: trouble", me ); return 1; } if ( nrrdBasicInfoCopy( nout, nin, NRRD_BASIC_INFO_ALL ^ NRRD_BASIC_INFO_SPACE ) ) { biffAddf( NRRD, "%s:", me ); return 1; } return 0; } int tenAnisoHistogram( Nrrd *nout, const Nrrd *nin, const Nrrd *nwght, int right, int version, unsigned int res ) { static const char me[]="tenAnisoHistogram"; size_t N, I; int csIdx, clIdx, cpIdx; float *tdata, *out, eval[3], cs, cl, cp, ( *wlup )( const void *data, size_t idx ), weight; unsigned int yres, xi, yi; if ( tenTensorCheck( nin, nrrdTypeFloat, AIR_TRUE, AIR_TRUE ) ) { biffAddf( TEN, "%s: didn't get a tensor nrrd", me ); return 1; } if ( nwght ) { if ( nrrdCheck( nwght ) ) { biffMovef( TEN, NRRD, "%s: trouble with weighting nrrd", me ); return 1; } if ( nrrdElementNumber( nwght ) != nrrdElementNumber( nin )/nrrdKindSize( nrrdKind3DMaskedSymMatrix ) ) { char stmp1[AIR_STRLEN_SMALL], stmp2[AIR_STRLEN_SMALL]; size_t numten; numten = nrrdElementNumber( nin )/nrrdKindSize( nrrdKind3DMaskedSymMatrix ); biffAddf( TEN, "%s: # elements in weight nrrd ( %s ) != # tensors ( %s )", me, airSprintSize_t( stmp1, nrrdElementNumber( nwght ) ), airSprintSize_t( stmp2, numten ) ); return 1; } } if ( !( 1 == version || 2 == version ) ) { biffAddf( TEN, "%s: version ( %d ) wasn't 1 or 2", me, version ); return 1; } if ( !( res > 10 ) ) { biffAddf( TEN, "%s: resolution ( %d ) invalid", me, res ); return 1; } if ( right ) { yres = AIR_CAST( unsigned int, AIR_CAST( double, res )/sqrt( 3 ) ); } else { yres = res; } if ( nwght ) { wlup = nrrdFLookup[nwght->type]; } else { wlup = NULL; } if ( nrrdMaybeAlloc_va( nout, nrrdTypeFloat, 2, AIR_CAST( size_t, res ), AIR_CAST( size_t, yres ) ) ) { biffMovef( TEN, NRRD, "%s: ", me ); return 1; } out = ( float * )nout->data; tdata = ( float * )nin->data; if ( right || 1 == version ) { clIdx = tenAniso_Cl1; cpIdx = tenAniso_Cp1; csIdx = tenAniso_Cs1; } else { clIdx = tenAniso_Cl2; cpIdx = tenAniso_Cp2; csIdx = tenAniso_Cs2; } N = nrrdElementNumber( nin )/nrrdKindSize( nrrdKind3DMaskedSymMatrix ); for ( I=0; I<N; I++ ) { tenEigensolve_f( eval, NULL, tdata ); cl = tenAnisoEval_f( eval, clIdx ); cp = tenAnisoEval_f( eval, cpIdx ); cs = tenAnisoEval_f( eval, csIdx ); if ( right ) { xi = AIR_CAST( unsigned int, cs*0 + cl*( res-1 ) + cp*0 ); yi = AIR_CAST( unsigned int, cs*0 + cl*( yres-1 ) + cp*( yres-1 ) ); } else { xi = AIR_CAST( unsigned int, cs*0 + cl*0 + cp*( res-1 ) ); yi = AIR_CAST( unsigned int, cs*0 + cl*( res-1 ) + cp*( res-1 ) ); } weight = wlup ? wlup( nwght->data, I ) : 1.0f; if ( xi < res && yi < yres-1 ) { out[xi + res*yi] += tdata[0]*weight; } tdata += nrrdKindSize( nrrdKind3DMaskedSymMatrix ); } return 0; } tenEvecRGBParm * tenEvecRGBParmNew( ) { tenEvecRGBParm *rgbp; rgbp = AIR_CAST( tenEvecRGBParm *, calloc( 1, sizeof( tenEvecRGBParm ) ) ); if ( rgbp ) { rgbp->which = 0; rgbp->aniso = tenAniso_Cl2; rgbp->confThresh = 0.5; rgbp->anisoGamma = 1.0; rgbp->gamma = 1.0; rgbp->bgGray = 0.0; rgbp->isoGray = 0.0; rgbp->maxSat = 1.0; rgbp->typeOut = nrrdTypeFloat; rgbp->genAlpha = AIR_FALSE; } return rgbp; } tenEvecRGBParm * tenEvecRGBParmNix( tenEvecRGBParm *rgbp ) { if ( rgbp ) { airFree( rgbp ); } return NULL; } int tenEvecRGBParmCheck( const tenEvecRGBParm *rgbp ) { static const char me[]="tenEvecRGBParmCheck"; if ( !rgbp ) { biffAddf( TEN, "%s: got NULL pointer", me ); return 1; } if ( !( rgbp->which <= 2 ) ) { biffAddf( TEN, "%s: which must be 0, 1, or 2 ( not %u )", me, rgbp->which ); return 1; } if ( airEnumValCheck( tenAniso, rgbp->aniso ) ) { biffAddf( TEN, "%s: anisotropy metric %d not valid", me, rgbp->aniso ); return 1; } if ( nrrdTypeDefault != rgbp->typeOut && airEnumValCheck( nrrdType, rgbp->typeOut ) ) { biffAddf( TEN, "%s: output type ( %d ) not valid", me, rgbp->typeOut ); return 1; } return 0; } float _tenEvecRGBComp_f( float conf, float aniso, float comp, const tenEvecRGBParm *rgbp ) { double X; X = AIR_ABS( comp ); X = pow( X, 1.0/rgbp->gamma ); X = AIR_LERP( rgbp->maxSat*aniso, rgbp->isoGray, X ); return AIR_CAST( float, conf > rgbp->confThresh ? X : rgbp->bgGray ); } double _tenEvecRGBComp_d( double conf, double aniso, double comp, const tenEvecRGBParm *rgbp ) { double X; X = AIR_ABS( comp ); X = pow( X, 1.0/rgbp->gamma ); X = AIR_LERP( rgbp->maxSat*aniso, rgbp->isoGray, X ); return conf > rgbp->confThresh ? X : rgbp->bgGray; } void tenEvecRGBSingle_f( float RGB[3], float conf, const float eval[3], const float evec[3], const tenEvecRGBParm *rgbp ) { float aniso; if ( RGB && eval && rgbp ) { aniso = tenAnisoEval_f( eval, rgbp->aniso ); aniso = AIR_CAST( float, pow( aniso, 1.0/rgbp->anisoGamma ) ); ELL_3V_SET( RGB, _tenEvecRGBComp_f( conf, aniso, evec[0], rgbp ), _tenEvecRGBComp_f( conf, aniso, evec[1], rgbp ), _tenEvecRGBComp_f( conf, aniso, evec[2], rgbp ) ); } return; } void tenEvecRGBSingle_d( double RGB[3], double conf, const double eval[3], const double evec[3], const tenEvecRGBParm *rgbp ) { double aniso; if ( RGB && eval && rgbp ) { aniso = tenAnisoEval_d( eval, rgbp->aniso ); aniso = pow( aniso, 1.0/rgbp->anisoGamma ); ELL_3V_SET( RGB, _tenEvecRGBComp_d( conf, aniso, evec[0], rgbp ), _tenEvecRGBComp_d( conf, aniso, evec[1], rgbp ), _tenEvecRGBComp_d( conf, aniso, evec[2], rgbp ) ); } return; }

/Users/scm/git/github/teem/src/ten/bimod.c

/Users/scm/git/github/teem/src/ten/bvec.c

/Users/scm/git/github/teem/src/ten/chan.c

/Users/scm/git/github/teem/src/ten/defaultsTen.c

/Users/scm/git/github/teem/src/ten/enumsTen.c

/Users/scm/git/github/teem/src/ten/epireg.c

/Users/scm/git/github/teem/src/ten/estimate.c

/Users/scm/git/github/teem/src/ten/experSpec.c

/Users/scm/git/github/teem/src/ten/fiber.c

/Users/scm/git/github/teem/src/ten/fiberMethods.c

/Users/scm/git/github/teem/src/ten/glyph.c

/Users/scm/git/github/teem/src/ten/grads.c

/Users/scm/git/github/teem/src/ten/miscTen.c

/Users/scm/git/github/teem/src/ten/mod.c

/Users/scm/git/github/teem/src/ten/model1Cylinder.c

/Users/scm/git/github/teem/src/ten/model1Stick.c

/Users/scm/git/github/teem/src/ten/model1Tensor2.c

/Users/scm/git/github/teem/src/ten/model1Unit2D.c

/Users/scm/git/github/teem/src/ten/model1Vector2D.c

/Users/scm/git/github/teem/src/ten/model2Unit2D.c

/Users/scm/git/github/teem/src/ten/modelB0.c

/Users/scm/git/github/teem/src/ten/modelBall.c

/Users/scm/git/github/teem/src/ten/modelBall1Cylinder.c

/Users/scm/git/github/teem/src/ten/modelBall1Stick.c

/Users/scm/git/github/teem/src/ten/modelBall1StickEMD.c

/Users/scm/git/github/teem/src/ten/modelZero.c

/Users/scm/git/github/teem/src/ten/path.c

/Users/scm/git/github/teem/src/ten/qglox.c

/Users/scm/git/github/teem/src/ten/qseg.c

/Users/scm/git/github/teem/src/ten/tenDwiGage.c

/Users/scm/git/github/teem/src/ten/tenGage.c

/Users/scm/git/github/teem/src/ten/tenModel.c

/Users/scm/git/github/teem/src/ten/tendAbout.c

/Users/scm/git/github/teem/src/ten/tendAnhist.c

/Users/scm/git/github/teem/src/ten/tendAnplot.c

/Users/scm/git/github/teem/src/ten/tendAnscale.c

/Users/scm/git/github/teem/src/ten/tendAnvol.c

/Users/scm/git/github/teem/src/ten/tendAvg.c

/Users/scm/git/github/teem/src/ten/tendBfit.c

/Users/scm/git/github/teem/src/ten/tendBmat.c

/Users/scm/git/github/teem/src/ten/tendEllipse.c

/Users/scm/git/github/teem/src/ten/tendEpireg.c

/Users/scm/git/github/teem/src/ten/tendEstim.c

/Users/scm/git/github/teem/src/ten/tendEval.c

/Users/scm/git/github/teem/src/ten/tendEvaladd.c

/Users/scm/git/github/teem/src/ten/tendEvalclamp.c

/Users/scm/git/github/teem/src/ten/tendEvalmult.c

/Users/scm/git/github/teem/src/ten/tendEvalpow.c

/Users/scm/git/github/teem/src/ten/tendEvec.c

/Users/scm/git/github/teem/src/ten/tendEvecrgb.c

/Users/scm/git/github/teem/src/ten/tendEvq.c

/Users/scm/git/github/teem/src/ten/tendExp.c

/Users/scm/git/github/teem/src/ten/tendExpand.c

/Users/scm/git/github/teem/src/ten/tendFiber.c

/Users/scm/git/github/teem/src/ten/tendFlotsam.c

/Users/scm/git/github/teem/src/ten/tendGlyph.c

/Users/scm/git/github/teem/src/ten/tendGrads.c

/Users/scm/git/github/teem/src/ten/tendHelix.c

/Users/scm/git/github/teem/src/ten/tendLog.c

/Users/scm/git/github/teem/src/ten/tendMake.c

/Users/scm/git/github/teem/src/ten/tendMconv.c

/Users/scm/git/github/teem/src/ten/tendMfit.c

/Users/scm/git/github/teem/src/ten/tendMsim.c

/Users/scm/git/github/teem/src/ten/tendNorm.c

/Users/scm/git/github/teem/src/ten/tendPoint.c

/Users/scm/git/github/teem/src/ten/tendSatin.c

/Users/scm/git/github/teem/src/ten/tendShrink.c

/Users/scm/git/github/teem/src/ten/tendSim.c

/Users/scm/git/github/teem/src/ten/tendSlice.c

/Users/scm/git/github/teem/src/ten/tendSten.c

/Users/scm/git/github/teem/src/ten/tendTconv.c

/Users/scm/git/github/teem/src/ten/tendTriple.c

/Users/scm/git/github/teem/src/ten/tendUnmf.c

/Users/scm/git/github/teem/src/ten/tensor.c

/Users/scm/git/github/teem/src/ten/test/cntr.c

/Users/scm/git/github/teem/src/ten/test/csim.c

/Users/scm/git/github/teem/src/ten/test/geode.c

/Users/scm/git/github/teem/src/ten/test/igrt.c

/Users/scm/git/github/teem/src/ten/test/odf-hist.c

/Users/scm/git/github/teem/src/ten/test/rgbprobe.c

/Users/scm/git/github/teem/src/ten/test/roistat.c

/Users/scm/git/github/teem/src/ten/test/rotedge.c

/Users/scm/git/github/teem/src/ten/test/taniso.c

/Users/scm/git/github/teem/src/ten/test/teigen-evals-A.c

double mean, norm, rnorm, Q, R, QQQ, D, theta, M00, M01, M02, M11, M12, M22; double epsilon = 1.0E-12; int roots; /* copy the given matrix elements */ 7 M00 = _M00; 8 M01 = _M01; M02 = _M02; M11 = _M11; M12 = _M12; M22 = _M22; /* ** subtract out the eigenvalue mean ( will add back to evals later ); ** helps with numerical stability */ mean = ( M00 + M11 + M22 )/3.0; M00 -= mean; M11 -= mean; M22 -= mean; /* ** divide out L2 norm of eigenvalues ( will multiply back later ); ** this too seems to help with stability */ norm = sqrt( M00*M00 + 2*M01*M01 + 2*M02*M02 + M11*M11 + 2*M12*M12 + M22*M22 ); rnorm = norm ? 1.0/norm : 1.0; M00 *= rnorm; M01 *= rnorm; M02 *= rnorm; M11 *= rnorm; M12 *= rnorm; M22 *= rnorm; /* this code is a mix of prior Teem code and ideas from Eberly's "Eigensystems for 3 x 3 Symmetric Matrices ( Revisited )" */ Q = ( M01*M01 + M02*M02 + M12*M12 - M00*M11 - M00*M22 - M11*M22 )/3.0; QQQ = Q*Q*Q; R = ( M00*M11*M22 + M02*( 2*M01*M12 - M02*M11 ) - M00*M12*M12 - M01*M01*M22 )/2.0; D = QQQ - R*R; if ( D > epsilon ) { /* three distinct roots- this is the most common case */ double mm, ss, cc; theta = atan2( sqrt( D ), R )/3.0; mm = sqrt( Q ); ss = sin( theta ); cc = cos( theta ); eval[0] = 2*mm*cc; eval[1] = mm*( -cc + sqrt( 3.0 )*ss ); eval[2] = mm*( -cc - sqrt( 3.0 )*ss ); roots = ROOT_THREE; /* else D is near enough to zero */ } else if ( R < -epsilon || epsilon < R ) { double U; /* one double root and one single root */ U = airCbrt( R ); /* cube root function */ if ( U > 0 ) { eval[0] = 2*U; eval[1] = -U; eval[2] = -U; } else { eval[0] = -U; eval[1] = -U; eval[2] = 2*U; } roots = ROOT_SINGLE_DOUBLE; } else { /* a triple root! */ eval[0] = eval[1] = eval[2] = 0.0; roots = ROOT_TRIPLE; }

/Users/scm/git/github/teem/src/ten/test/teigen-evals-B.c

/* multiply back by eigenvalue L2 norm */ 3 eval[0] /= rnorm; 4 eval[1] /= rnorm; eval[2] /= rnorm; /* add back in the eigenvalue mean */ eval[0] += mean; eval[1] += mean; eval[2] += mean;

/Users/scm/git/github/teem/src/ten/test/teigen.c

1 /* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2013, 2012, 2011, 2010, 2009, University of Chicago Copyright ( C ) 2008, 2007, 2006, 2005 Gordon Kindlmann Copyright ( C ) 2004, 2003, 2002, 2001, 2000, 1999, 1998 University of Utah This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "../ten.h" char *info = ( "tests tenEigensolve_d and new stand-alone function." ); #define ROOT_TRIPLE 2 /* ell_cubic_root_triple */ #define ROOT_SINGLE_DOUBLE 3 /* ell_cubic_root_single_double */ #define ROOT_THREE 4 /* ell_cubic_root_three */ #define ABS( a ) ( ( ( a ) > 0.0f ? ( a ) : -( a ) ) ) #define VEC_SET( v, a, b, c ) \ ( ( v )[0] = ( a ), ( v )[1] = ( b ), ( v )[2] = ( c ) ) #define VEC_DOT( v1, v2 ) \ ( ( v1 )[0]*( v2 )[0] + ( v1 )[1]*( v2 )[1] + ( v1 )[2]*( v2 )[2] ) #define VEC_CROSS( v3, v1, v2 ) \ ( ( v3 )[0] = ( v1 )[1]*( v2 )[2] - ( v1 )[2]*( v2 )[1], \ ( v3 )[1] = ( v1 )[2]*( v2 )[0] - ( v1 )[0]*( v2 )[2], \ ( v3 )[2] = ( v1 )[0]*( v2 )[1] - ( v1 )[1]*( v2 )[0] ) #define VEC_ADD( v1, v2 ) \ ( ( v1 )[0] += ( v2 )[0], \ ( v1 )[1] += ( v2 )[1], \ ( v1 )[2] += ( v2 )[2] ) #define VEC_SUB( v1, v2 ) \ ( ( v1 )[0] -= ( v2 )[0], \ ( v1 )[1] -= ( v2 )[1], \ ( v1 )[2] -= ( v2 )[2] ) #define VEC_SCL( v1, s ) \ ( ( v1 )[0] *= ( s ), \ 52 ( v1 )[1] *= ( s ), \ ( v1 )[2] *= ( s ) ) #define VEC_LEN( v ) ( sqrt( VEC_DOT( v, v ) ) ) #define VEC_NORM( v, len ) ( ( len ) = VEC_LEN( v ), VEC_SCL( v, 1.0/len ) ) #define VEC_SCL_SUB( v1, s, v2 ) \ ( ( v1 )[0] -= ( s )*( v2 )[0], \ ( v1 )[1] -= ( s )*( v2 )[1], \ ( v1 )[2] -= ( s )*( v2 )[2] ) #define VEC_COPY( v1, v2 ) \ ( ( v1 )[0] = ( v2 )[0], \ ( v1 )[1] = ( v2 )[1], \ ( v1 )[2] = ( v2 )[2] ) /* ** All the three given vectors span only a 2D space, and this finds ** the normal to that plane. Simply sums up all the pair-wise ** cross-products to get a good estimate. Trick is getting the cross ** products to line up before summing. */ void nullspace1( double ret[3], const double r0[3], const double r1[3], const double r2[3] ) { double crs[3]; /* ret = r0 x r1 */ VEC_CROSS( ret, r0, r1 ); /* crs = r1 x r2 */ VEC_CROSS( crs, r1, r2 ); /* ret += crs or ret -= crs; whichever makes ret longer */ if ( VEC_DOT( ret, crs ) > 0 ) { VEC_ADD( ret, crs ); 83 } else { VEC_SUB( ret, crs ); } /* crs = r0 x r2 */ VEC_CROSS( crs, r0, r2 ); /* ret += crs or ret -= crs; whichever makes ret longer */ if ( VEC_DOT( ret, crs ) > 0 ) { VEC_ADD( ret, crs ); } else { VEC_SUB( ret, crs ); } return; } /* ** All vectors are in the same 1D space, we have to find two ** mutually vectors perpendicular to that span */ void nullspace2( double reta[3], double retb[3], const double r0[3], const double r1[3], const double r2[3] ) { double sqr[3], sum[3]; int idx; VEC_COPY( sum, r0 ); if ( VEC_DOT( sum, r1 ) > 0 ) { VEC_ADD( sum, r1 ); } else { VEC_SUB( sum, r1 ); } if ( VEC_DOT( sum, r2 ) > 0 ) { VEC_ADD( sum, r2 ); } else { VEC_SUB( sum, r2 ); } /* find largest component, to get most stable expression for a perpendicular vector */ sqr[0] = sum[0]*sum[0]; sqr[1] = sum[1]*sum[1]; sqr[2] = sum[2]*sum[2]; idx = 0; if ( sqr[0] < sqr[1] ) idx = 1; if ( sqr[idx] < sqr[2] ) idx = 2; /* reta will be perpendicular to sum */ if ( 0 == idx ) { VEC_SET( reta, sum[1] - sum[2], -sum[0], sum[0] ); } else if ( 1 == idx ) { VEC_SET( reta, -sum[1], sum[0] - sum[2], sum[1] ); } else { VEC_SET( reta, -sum[2], sum[2], sum[0] - sum[1] ); } /* and now retb will be perpendicular to both reta and sum */ VEC_CROSS( retb, reta, sum ); return; } /* ** Eigensolver for symmetric 3x3 matrix: ** ** M00 M01 M02 ** M01 M11 M12 ** M02 M12 M22 ** ** Must be passed eval[3] vector, and will compute eigenvalues ** only if evec[9] is non-NULL. Computed eigenvectors are at evec+0, ** evec+3, and evec+6. ** ** Return value indicates something about the eigenvalue solution to ** the cubic characteristic equation; see ROOT_ #defines above ** ** Relies on the ABS and VEC_* macros above, as well as math functions 157 ** atan2( ), sin( ), cos( ), sqrt( ), and airCbrt( ), defined as: double airCbrt( double v ) { #if defined( _WIN32 ) || defined( __STRICT_ANSI__ ) return ( v < 0.0 ? -pow( -v, 1.0/3.0 ) : pow( v, 1.0/3.0 ) ); #else return cbrt( v ); #endif } ** ** HEY: the numerical precision issues here are very subtle, and 170 ** merit some more scrutiny. With evals ( 1.000001, 1, 1 ), for example, ** whether it comes back as a single/double root, vs three distinct roots, ** is determines by the comparison between "D" and "epsilon", and the ** setting of epsilon seems pretty arbitrary at this point... ** */ int evals( double eval[3], const double _M00, const double _M01, const double _M02, const double _M11, const double _M12, const double _M22 ) { #include "teigen-evals-A.c" #include "teigen-evals-B.c" return roots; } int evals_evecs( double eval[3], double evec[9], const double _M00, const double _M01, const double _M02, const double _M11, const double _M12, const double _M22 ) { double r0[3], r1[3], r2[3], crs[3], len, dot; double mean, norm, rnorm, Q, R, QQQ, D, theta, M00, M01, M02, M11, M12, M22; double epsilon = 1.0E-12; int roots; /* copy the given matrix elements */ M00 = _M00; M01 = _M01; M02 = _M02; M11 = _M11; M12 = _M12; M22 = _M22; /* ** subtract out the eigenvalue mean ( will add back to evals later ); ** helps with numerical stability */ mean = ( M00 + M11 + M22 )/3.0; M00 -= mean; M11 -= mean; M22 -= mean; /* ** divide out L2 norm of eigenvalues ( will multiply back later ); ** this too seems to help with stability */ norm = sqrt( M00*M00 + 2*M01*M01 + 2*M02*M02 + M11*M11 + 2*M12*M12 + M22*M22 ); rnorm = norm ? 1.0/norm : 1.0; M00 *= rnorm; M01 *= rnorm; M02 *= rnorm; M11 *= rnorm; M12 *= rnorm; M22 *= rnorm; /* this code is a mix of prior Teem code and ideas from Eberly's "Eigensystems for 3 x 3 Symmetric Matrices ( Revisited )" */ Q = ( M01*M01 + M02*M02 + M12*M12 - M00*M11 - M00*M22 - M11*M22 )/3.0; QQQ = Q*Q*Q; R = ( M00*M11*M22 + M02*( 2*M01*M12 - M02*M11 ) - M00*M12*M12 - M01*M01*M22 )/2.0; D = QQQ - R*R; if ( D > epsilon ) { /* three distinct roots- this is the most common case */ double mm, ss, cc; theta = atan2( sqrt( D ), R )/3.0; mm = sqrt( Q ); ss = sin( theta ); cc = cos( theta ); eval[0] = 2*mm*cc; eval[1] = mm*( -cc + sqrt( 3.0 )*ss ); eval[2] = mm*( -cc - sqrt( 3.0 )*ss ); roots = ROOT_THREE; /* else D is near enough to zero */ } else if ( R < -epsilon || epsilon < R ) { double U; /* one double root and one single root */ U = airCbrt( R ); /* cube root function */ if ( U > 0 ) { eval[0] = 2*U; eval[1] = -U; eval[2] = -U; } else { eval[0] = -U; eval[1] = -U; eval[2] = 2*U; } roots = ROOT_SINGLE_DOUBLE; } else { /* a triple root! */ eval[0] = eval[1] = eval[2] = 0.0; roots = ROOT_TRIPLE; } /* r0, r1, r2 are the vectors we manipulate to find the nullspaces of M - lambda*I */ VEC_SET( r0, 0.0, M01, M02 ); VEC_SET( r1, M01, 0.0, M12 ); VEC_SET( r2, M02, M12, 0.0 ); if ( ROOT_THREE == roots ) { r0[0] = M00 - eval[0]; r1[1] = M11 - eval[0]; r2[2] = M22 - eval[0]; nullspace1( evec+0, r0, r1, r2 ); r0[0] = M00 - eval[1]; r1[1] = M11 - eval[1]; r2[2] = M22 - eval[1]; nullspace1( evec+3, r0, r1, r2 ); r0[0] = M00 - eval[2]; r1[1] = M11 - eval[2]; r2[2] = M22 - eval[2]; nullspace1( evec+6, r0, r1, r2 ); } else if ( ROOT_SINGLE_DOUBLE == roots ) { if ( eval[1] == eval[2] ) { /* one big ( eval[0] ) , two small ( eval[1, 2] ) */ r0[0] = M00 - eval[0]; r1[1] = M11 - eval[0]; r2[2] = M22 - eval[0]; nullspace1( evec+0, r0, r1, r2 ); r0[0] = M00 - eval[1]; r1[1] = M11 - eval[1]; r2[2] = M22 - eval[1]; nullspace2( evec+3, evec+6, r0, r1, r2 ); } else { /* two big ( eval[0, 1] ), one small ( eval[2] ) */ r0[0] = M00 - eval[0]; r1[1] = M11 - eval[0]; r2[2] = M22 - eval[0]; nullspace2( evec+0, evec+3, r0, r1, r2 ); r0[0] = M00 - eval[2]; r1[1] = M11 - eval[2]; r2[2] = M22 - eval[2]; nullspace1( evec+6, r0, r1, r2 ); } } else { /* ROOT_TRIPLE == roots; use any basis for eigenvectors */ VEC_SET( evec+0, 1, 0, 0 ); VEC_SET( evec+3, 0, 1, 0 ); VEC_SET( evec+6, 0, 0, 1 ); } /* we always make sure its really orthonormal; keeping fixed the eigenvector associated with the largest-magnitude eigenvalue */ if ( ABS( eval[0] ) > ABS( eval[2] ) ) { /* normalize evec+0 but don't move it */ VEC_NORM( evec+0, len ); dot = VEC_DOT( evec+0, evec+3 ); VEC_SCL_SUB( evec+3, dot, evec+0 ); VEC_NORM( evec+3, len ); dot = VEC_DOT( evec+0, evec+6 ); VEC_SCL_SUB( evec+6, dot, evec+0 ); dot = VEC_DOT( evec+3, evec+6 ); VEC_SCL_SUB( evec+6, dot, evec+3 ); VEC_NORM( evec+6, len ); } else { /* normalize evec+6 but don't move it */ VEC_NORM( evec+6, len ); dot = VEC_DOT( evec+6, evec+3 ); VEC_SCL_SUB( evec+3, dot, evec+6 ); VEC_NORM( evec+3, len ); dot = VEC_DOT( evec+3, evec+0 ); VEC_SCL_SUB( evec+0, dot, evec+3 ); dot = VEC_DOT( evec+6, evec+0 ); VEC_SCL_SUB( evec+0, dot, evec+6 ); VEC_NORM( evec+0, len ); } /* to be nice, make it right-handed */ 326 VEC_CROSS( crs, evec+0, evec+3 ); if ( 0 > VEC_DOT( crs, evec+6 ) ) { VEC_SCL( evec+6, -1 ); } /* multiply back by eigenvalue L2 norm */ eval[0] /= rnorm; eval[1] /= rnorm; eval[2] /= rnorm; /* add back in the eigenvalue mean */ eval[0] += mean; eval[1] += mean; eval[2] += mean; return roots; } void testeigen( double tt[7], double eval[3], double evec[9] ) { double mat[9], dot[3], cross[3]; unsigned int ii; TEN_T2M( mat, tt ); printf( "evals %g %g %g\n", eval[0], eval[1], eval[2] ); printf( "evec0 ( %g ) %g %g %g\n", ELL_3V_LEN( evec + 0 ), evec[0], evec[1], evec[2] ); printf( "evec1 ( %g ) %g %g %g\n", ELL_3V_LEN( evec + 3 ), evec[3], evec[4], evec[5] ); printf( "evec2 ( %g ) %g %g %g\n", 357 ELL_3V_LEN( evec + 6 ), evec[6], evec[7], evec[8] ); printf( "Mv - lv: ( len ) X Y Z ( should be ~zeros )\n" ); for ( ii=0; ii<3; ii++ ) { double uu[3], vv[3], dd[3]; ELL_3MV_MUL( uu, mat, evec + 3*ii ); ELL_3V_SCALE( vv, eval[ii], evec + 3*ii ); ELL_3V_SUB( dd, uu, vv ); printf( "%d: ( %g ) %g %g %g\n", ii, ELL_3V_LEN( dd ), dd[0], dd[1], dd[2] ); } dot[0] = ELL_3V_DOT( evec + 0, evec + 3 ); dot[1] = ELL_3V_DOT( evec + 0, evec + 6 ); dot[2] = ELL_3V_DOT( evec + 3, evec + 6 ); printf( "pairwise dots: ( %g ) %g %g %g\n", ELL_3V_LEN( dot ), dot[0], dot[1], dot[2] ); ELL_3V_CROSS( cross, evec+0, evec+3 ); printf( "right-handed: %g\n", ELL_3V_DOT( evec+6, cross ) ); return; } int main( int argc, const char *argv[] ) { const char *me; hestOpt *hopt=NULL; airArray *mop; double _tt[6], tt[7], ss, pp[3], qq[4], rot[9], mat1[9], mat2[9], tmp, evalA[3], evecA[9], evalB[3], evecB[9]; int roots; mop = airMopNew( ); me = argv[0]; hestOptAdd( &hopt, NULL, "m00 m01 m02 m11 m12 m22", airTypeDouble, 6, 6, _tt, NULL, "symmtric matrix coeffs" ); hestOptAdd( &hopt, "p", "vec", airTypeDouble, 3, 3, pp, "0 0 0", "rotation as P vector" ); hestOptAdd( &hopt, "s", "scl", airTypeDouble, 1, 1, &ss, "1.0", "scaling" ); hestParseOrDie( hopt, argc-1, argv+1, NULL, me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE ); airMopAdd( mop, hopt, ( airMopper )hestOptFree, airMopAlways ); airMopAdd( mop, hopt, ( airMopper )hestParseFree, airMopAlways ); ELL_6V_COPY( tt + 1, _tt ); tt[0] = 1.0; TEN_T_SCALE( tt, ss, tt ); ELL_4V_SET( qq, 1, pp[0], pp[1], pp[2] ); ELL_4V_NORM( qq, qq, tmp ); ell_q_to_3m_d( rot, qq ); printf( "%s: rot\n", me ); printf( " %g %g %g\n", rot[0], rot[1], rot[2] ); printf( " %g %g %g\n", rot[3], rot[4], rot[5] ); printf( " %g %g %g\n", rot[6], rot[7], rot[8] ); TEN_T2M( mat1, tt ); ell_3m_mul_d( mat2, rot, mat1 ); ELL_3M_TRANSPOSE_IP( rot, tmp ); ell_3m_mul_d( mat1, mat2, rot ); TEN_M2T( tt, mat1 ); printf( "input matrix = \n %g %g %g\n %g %g\n %g\n", tt[1], tt[2], tt[3], tt[4], tt[5], tt[6] ); printf( "================== tenEigensolve_d ==================\n" ); roots = tenEigensolve_d( evalA, evecA, tt ); printf( "%s roots\n", airEnumStr( ell_cubic_root, roots ) ); testeigen( tt, evalA, evecA ); printf( "================== new eigensolve ==================\n" ); roots = evals( evalB, tt[1], tt[2], tt[3], tt[4], tt[5], tt[6] ); printf( "%s roots: %g %g %g\n", airEnumStr( ell_cubic_root, roots ), evalB[0], evalB[1], evalB[2] ); roots = evals_evecs( evalB, evecB, tt[1], tt[2], tt[3], tt[4], tt[5], tt[6] ); printf( "%s roots\n", airEnumStr( ell_cubic_root, roots ) ); testeigen( tt, evalB, evecB ); airMopOkay( mop ); return 0; }

/Users/scm/git/github/teem/src/ten/test/tem.c

/Users/scm/git/github/teem/src/ten/test/tensorDotDat.c

/Users/scm/git/github/teem/src/ten/test/tg.c

/Users/scm/git/github/teem/src/ten/test/to.c

/Users/scm/git/github/teem/src/ten/test/tqgl.c

/Users/scm/git/github/teem/src/ten/test/tsoid.c

/Users/scm/git/github/teem/src/ten/test/tt.c

/Users/scm/git/github/teem/src/ten/test/ttriple.c

/Users/scm/git/github/teem/src/ten/triple.c

/Users/scm/git/github/teem/src/tijk/2dTijk.c

/* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2010, 2009, 2008 Thomas Schultz Copyright ( C ) 2010, 2009, 2008 Gordon Kindlmann This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /* Implementation of two-dimensional tensors */ #include "tijk.h" #include "privateTijk.h" #include "convertQuietPush.h" /* 2nd order 2D unsymmetric */ double 33 _tijk_2o2d_unsym_tsp_d ( const double *A, const double *B ) { return ELL_4V_DOT( A, B ); } float 38 _tijk_2o2d_unsym_tsp_f ( const float *A, const float *B ) { return ELL_4V_DOT( A, B ); } double 43 _tijk_2o2d_unsym_norm_d ( const double *A ) { return sqrt( ELL_4V_DOT( A, A ) ); } float 48 _tijk_2o2d_unsym_norm_f ( const float *A ) { return sqrt( ELL_4V_DOT( A, A ) ); } void 53 _tijk_2o2d_unsym_trans_d ( double *res, const double *A, const double *M ) { double _ma[4], _mt[4]; ELL_2M_MUL( _ma, M, A ); ELL_2M_TRANSPOSE( _mt, M ); ELL_2M_MUL( res, _ma, _mt ); } void 61 _tijk_2o2d_unsym_trans_f ( float *res, const float *A, const float *M ) { float _ma[4], _mt[4]; ELL_2M_MUL( _ma, M, A ); ELL_2M_TRANSPOSE( _mt, M ); ELL_2M_MUL( res, _ma, _mt ); } /* macro-based pseudo-template for type-generic code */ #define _TIJK_2O2D_UNSYM_CONVERT( TYPE, SUF ) \ 70 int \ _tijk_2o2d_unsym_convert_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_2o2d_unsym ) { /* copy over */ \ ELL_4V_COPY( res, A ); \ return 0; \ } else if ( NULL!=res_type->_convert_from_##SUF ) \ return ( *res_type->_convert_from_##SUF )( res, A, tijk_2o2d_unsym ); \ else \ return 1; \ } _TIJK_2O2D_UNSYM_CONVERT( double, d ) _TIJK_2O2D_UNSYM_CONVERT( float, f ) #define _TIJK_2O2D_UNSYM_APPROX( TYPE, SUF ) \ int \ _tijk_2o2d_unsym_approx_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_2o2d_sym ) { \ res[0]=A[0]; res[1]=0.5*( A[1]+A[2] ); res[2]=A[3]; \ return 0; \ } else if ( res_type==tijk_2o2d_asym ) { \ res[0]=0.5*( A[1]-A[2] ); \ return 0; \ } else if ( NULL!=res_type->_approx_from_##SUF ) \ return ( *res_type->_approx_from_##SUF )( res, A, tijk_2o2d_unsym ); \ else \ return 1; \ } _TIJK_2O2D_UNSYM_APPROX( double, d ) _TIJK_2O2D_UNSYM_APPROX( float, f ) TIJK_TYPE_UNSYM( 2o2d_unsym, 2, 2, 4 ) /* 2nd order 2D symmetric */ unsigned int _tijk_2o2d_sym_mult[3] = {1, 2, 1}; int _tijk_2o2d_sym_unsym2uniq[4] = {1, 2, 2, 3}; int _tijk_2o2d_sym_uniq2unsym[4] = {1, 2, 3, 4}; unsigned int _tijk_2o2d_sym_uniq_idx[3] = {0, 1, 3}; #define _TIJK_2O2D_SYM_TSP( A, B ) \ ( ( A )[0]*( B )[0]+2*( A )[1]*( B )[1]+( A )[2]*( B )[2] ) double _tijk_2o2d_sym_tsp_d ( const double *A, const double *B ) { return _TIJK_2O2D_SYM_TSP( A, B ); } float _tijk_2o2d_sym_tsp_f ( const float *A, const float *B ) { return _TIJK_2O2D_SYM_TSP( A, B ); } double _tijk_2o2d_sym_norm_d ( const double *A ) { return sqrt( _TIJK_2O2D_SYM_TSP( A, A ) ); } float _tijk_2o2d_sym_norm_f ( const float *A ) { return sqrt( _TIJK_2O2D_SYM_TSP( A, A ) ); } void _tijk_2o2d_sym_trans_d ( double *res, const double *A, const double *M ) { /* sym( M*unsym( A )*M^T ) written out: */ res[0]=M[0]*M[0]*A[0]+2*M[0]*M[1]*A[1]+M[1]*M[1]*A[2]; res[1]=M[0]*M[2]*A[0]+( M[0]*M[3]+M[1]*M[2] )*A[1]+M[1]*M[3]*A[2]; res[2]=M[2]*M[2]*A[0]+2*M[2]*M[3]*A[1]+M[3]*M[3]*A[2]; } void _tijk_2o2d_sym_trans_f ( float *res, const float *A, const float *M ) { /* sym( M*unsym( A )*M^T ) written out: */ res[0]=M[0]*M[0]*A[0]+2*M[0]*M[1]*A[1]+M[1]*M[1]*A[2]; res[1]=M[0]*M[2]*A[0]+( M[0]*M[3]+M[1]*M[2] )*A[1]+M[1]*M[3]*A[2]; res[2]=M[2]*M[2]*A[0]+2*M[2]*M[3]*A[1]+M[3]*M[3]*A[2]; } #define _TIJK_2O2D_SYM_CONVERT( TYPE, SUF ) \ int \ _tijk_2o2d_sym_convert_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_2o2d_sym ) { /* copy over */ \ ELL_3V_COPY( res, A ); \ return 0; \ } else if ( res_type==tijk_2o2d_unsym ) { \ res[0]=A[0]; res[1]=res[2]=A[1]; res[3]=A[2]; \ return 0; \ } else if ( res_type==tijk_4o2d_sym ) { \ res[0]=A[0]; res[1]=res[3]=0.5*A[1]; \ res[2]=( A[0]+A[2] )/6.0; res[4]=A[2]; \ return 0; \ } else if ( NULL!=res_type->_convert_from_##SUF ) \ return ( *res_type->_convert_from_##SUF )( res, A, tijk_2o2d_sym ); \ else \ return 1; \ } _TIJK_2O2D_SYM_CONVERT( double, d ) _TIJK_2O2D_SYM_CONVERT( float, f ) #define _TIJK_2O2D_SYM_APPROX( TYPE, SUF ) \ int \ _tijk_2o2d_sym_approx_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( NULL!=res_type->_approx_from_##SUF ) \ return ( *res_type->_approx_from_##SUF )( res, A, tijk_2o2d_sym ); \ else \ return 1; \ } _TIJK_2O2D_SYM_APPROX( double, d ) _TIJK_2O2D_SYM_APPROX( float, f ) double _tijk_2o2d_sym_s_form_d ( const double *A, const double *v ) { return A[0]*v[0]*v[0]+2*A[1]*v[0]*v[1]+A[2]*v[1]*v[1]; } float _tijk_2o2d_sym_s_form_f ( const float *A, const float *v ) { return A[0]*v[0]*v[0]+2*A[1]*v[0]*v[1]+A[2]*v[1]*v[1]; } double _tijk_2o2d_sym_mean_d ( const double *A ) { return 0.5*( A[0]+A[2] ); } float _tijk_2o2d_sym_mean_f ( const float *A ) { return 0.5*( A[0]+A[2] ); } double _tijk_2o2d_sym_var_d ( const double *A ) { return 0.125*( A[0]*A[0]+A[2]*A[2] )-0.25*A[0]*A[2]+0.5*A[1]*A[1]; } float _tijk_2o2d_sym_var_f ( const float *A ) { return 0.125*( A[0]*A[0]+A[2]*A[2] )-0.25*A[0]*A[2]+0.5*A[1]*A[1]; } void _tijk_2o2d_sym_v_form_d ( double *res, const double *A, const double *v ) { res[0]=A[0]*v[0]+A[1]*v[1]; res[1]=A[1]*v[0]+A[2]*v[1]; } void _tijk_2o2d_sym_v_form_f ( float *res, const float *A, const float *v ) { res[0]=A[0]*v[0]+A[1]*v[1]; res[1]=A[1]*v[0]+A[2]*v[1]; } void _tijk_2o2d_sym_m_form_d ( double *res, const double *A, const double *v ) { ( void ) v; /* v is only used in higher-order cases */ res[0]=A[0]; res[1]=A[1]; res[2]=A[2]; } void _tijk_2o2d_sym_m_form_f ( float *res, const float *A, const float *v ) { ( void ) v; /* v is only used in higher-order cases */ res[0]=A[0]; res[1]=A[1]; res[2]=A[2]; } void _tijk_2o2d_sym_make_rank1_d ( double *res, const double s, const double *v ) { res[0]=s*v[0]*v[0]; res[1]=s*v[0]*v[1]; res[2]=s*v[1]*v[1]; } void _tijk_2o2d_sym_make_rank1_f ( float *res, const float s, const float *v ) { res[0]=s*v[0]*v[0]; res[1]=s*v[0]*v[1]; res[2]=s*v[1]*v[1]; } void _tijk_2o2d_sym_make_iso_d ( double *res, const double s ) { res[0]=s; res[1]=0; res[2]=s; } void _tijk_2o2d_sym_make_iso_f ( float *res, const float s ) { res[0]=s; res[1]=0; res[2]=s; } void _tijk_2o2d_sym_grad_d ( double *res, const double *A, const double *v ) { double proj, projv[2]; res[0]=2*( A[0]*v[0]+A[1]*v[1] ); res[1]=2*( A[1]*v[0]+A[2]*v[1] ); proj=ELL_2V_DOT( res, v ); ELL_2V_SCALE( projv, -proj, v ); ELL_2V_INCR( res, projv ); } void _tijk_2o2d_sym_grad_f ( float *res, const float *A, const float *v ) { float proj, projv[2]; res[0]=2*( A[0]*v[0]+A[1]*v[1] ); res[1]=2*( A[1]*v[0]+A[2]*v[1] ); proj=ELL_2V_DOT( res, v ); ELL_2V_SCALE( projv, -proj, v ); ELL_2V_INCR( res, projv ); } void _tijk_2o2d_sym_hess_d ( double *res, const double *A, const double *v ) { double tang[2], s; ELL_2V_SET( tang, v[1], -v[0] ); s=2*_tijk_2o2d_sym_s_form_d( A, tang )-2*_tijk_2o2d_sym_s_form_d( A, v ); _tijk_2o2d_sym_make_rank1_d( res, s, tang ); } void _tijk_2o2d_sym_hess_f ( float *res, const float *A, const float *v ) { float tang[2], s; ELL_2V_SET( tang, v[1], -v[0] ); s=2*_tijk_2o2d_sym_s_form_f( A, tang )-2*_tijk_2o2d_sym_s_form_f( A, v ); _tijk_2o2d_sym_make_rank1_f( res, s, tang ); } TIJK_TYPE_SYM( 2o2d_sym, 2, 2, 3 ) /* 2nd order 2D antisymmetric */ unsigned int _tijk_2o2d_asym_mult[1] = {2}; int _tijk_2o2d_asym_unsym2uniq[4] = {0, 1, -1, 0}; int _tijk_2o2d_asym_uniq2unsym[2] = {2, -3}; unsigned int _tijk_2o2d_asym_uniq_idx[1] = {0}; double _tijk_2o2d_asym_tsp_d ( const double *A, const double *B ) { return 2*A[0]*B[0]; } float _tijk_2o2d_asym_tsp_f ( const float *A, const float *B ) { return 2*A[0]*B[0]; } double _tijk_2o2d_asym_norm_d ( const double *A ) { return sqrt( 2*A[0]*A[0] ); } float _tijk_2o2d_asym_norm_f ( const float *A ) { return sqrt( 2*A[0]*A[0] ); } void _tijk_2o2d_asym_trans_d ( double *res, const double *A, const double *M ) { /* if M is a rotation, this amounts to the identity */ res[0]=A[0]*( M[0]*M[3]-M[1]*M[2] ); } void _tijk_2o2d_asym_trans_f ( float *res, const float *A, const float *M ) { res[0]=A[0]*( M[0]*M[3]-M[1]*M[2] ); } #define _TIJK_2O2D_ASYM_CONVERT( TYPE, SUF ) \ int \ _tijk_2o2d_asym_convert_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_2o2d_asym ) { /* copy over */ \ res[0]=A[0]; \ return 0; \ } else if ( res_type==tijk_2o2d_unsym ) { \ res[0]=0; res[1]=A[0]; res[2]=-A[0]; res[3]=0; \ return 0; \ } else if ( NULL!=res_type->_convert_from_##SUF ) \ return ( *res_type->_convert_from_##SUF )( res, A, tijk_2o2d_asym ); \ else \ return 1; \ } _TIJK_2O2D_ASYM_CONVERT( double, d ) _TIJK_2O2D_ASYM_CONVERT( float, f ) #define _TIJK_2O2D_ASYM_APPROX( TYPE, SUF ) \ int \ _tijk_2o2d_asym_approx_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( NULL!=res_type->_approx_from_##SUF ) \ return ( *res_type->_approx_from_##SUF )( res, A, tijk_2o2d_asym ); \ else \ return 1; \ } _TIJK_2O2D_ASYM_APPROX( double, d ) _TIJK_2O2D_ASYM_APPROX( float, f ) TIJK_TYPE( 2o2d_asym, 2, 2, 1 ) /* 3rd order 2D symmetric */ /* unsymmetric counterpart currently not implemented */ unsigned int _tijk_3o2d_sym_mult[4] = {1, 3, 3, 1}; #define _tijk_3o2d_sym_unsym2uniq NULL #define _tijk_3o2d_sym_uniq2unsym NULL #define _tijk_3o2d_sym_uniq_idx NULL #define _TIJK_3O2D_SYM_TSP( A, B ) \ ( ( A )[0]*( B )[0]+3*( A )[1]*( B )[1]+3*( A )[2]*( B )[2]+( A )[3]*( B )[3] ) double _tijk_3o2d_sym_tsp_d ( const double *A, const double *B ) { return _TIJK_3O2D_SYM_TSP( A, B ); } float _tijk_3o2d_sym_tsp_f ( const float *A, const float *B ) { return _TIJK_3O2D_SYM_TSP( A, B ); } double _tijk_3o2d_sym_norm_d ( const double *A ) { return sqrt( _TIJK_3O2D_SYM_TSP( A, A ) ); } float _tijk_3o2d_sym_norm_f ( const float *A ) { return sqrt( _TIJK_3O2D_SYM_TSP( A, A ) ); } #define _TIJK_3O2D_SYM_CONVERT( TYPE, SUF ) \ int \ _tijk_3o2d_sym_convert_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_3o2d_sym ) { /* copy over */ \ ELL_4V_COPY( res, A ); \ return 0; \ } else if ( NULL!=res_type->_convert_from_##SUF ) \ return ( *res_type->_convert_from_##SUF )( res, A, tijk_3o2d_sym ); \ else \ return 1; \ } _TIJK_3O2D_SYM_CONVERT( double, d ) _TIJK_3O2D_SYM_CONVERT( float, f ) #define _TIJK_3O2D_SYM_APPROX( TYPE, SUF ) \ int \ _tijk_3o2d_sym_approx_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( NULL!=res_type->_approx_from_##SUF ) \ return ( *res_type->_approx_from_##SUF )( res, A, tijk_3o2d_sym ); \ else \ return 1; \ } _TIJK_3O2D_SYM_APPROX( double, d ) _TIJK_3O2D_SYM_APPROX( float, f ) void _tijk_3o2d_sym_trans_d ( double *res, const double *A, const double *M ) { res[0]=M[0]*M[0]*M[0]*A[0]+3*M[0]*M[0]*M[1]*A[1]+ 3*M[0]*M[1]*M[1]*A[2]+M[1]*M[1]*M[1]*A[3]; res[1]=M[0]*M[0]*M[2]*A[0]+( M[0]*M[0]*M[3]+2*M[0]*M[1]*M[2] )*A[1]+ ( 2*M[0]*M[1]*M[3]+M[1]*M[1]*M[2] )*A[2]+M[1]*M[1]*M[3]*A[3]; res[2]=M[0]*M[2]*M[2]*A[0]+( M[1]*M[2]*M[2]+2*M[0]*M[2]*M[3] )*A[1]+ ( 2*M[1]*M[2]*M[3]+M[0]*M[3]*M[3] )*A[2]+M[1]*M[3]*M[3]*A[3]; res[3]=M[2]*M[2]*M[2]*A[0]+3*M[2]*M[2]*M[3]*A[1]+ 3*M[2]*M[3]*M[3]*A[2]+M[3]*M[3]*M[3]*A[3]; } void _tijk_3o2d_sym_trans_f ( float *res, const float *A, const float *M ) { res[0]=M[0]*M[0]*M[0]*A[0]+3*M[0]*M[0]*M[1]*A[1]+ 3*M[0]*M[1]*M[1]*A[2]+M[1]*M[1]*M[1]*A[3]; res[1]=M[0]*M[0]*M[2]*A[0]+( M[0]*M[0]*M[3]+2*M[0]*M[1]*M[2] )*A[1]+ ( 2*M[0]*M[1]*M[3]+M[1]*M[1]*M[2] )*A[2]+M[1]*M[1]*M[3]*A[3]; res[2]=M[0]*M[2]*M[2]*A[0]+( M[1]*M[2]*M[2]+2*M[0]*M[2]*M[3] )*A[1]+ ( 2*M[1]*M[2]*M[3]+M[0]*M[3]*M[3] )*A[2]+M[1]*M[3]*M[3]*A[3]; res[3]=M[2]*M[2]*M[2]*A[0]+3*M[2]*M[2]*M[3]*A[1]+ 3*M[2]*M[3]*M[3]*A[2]+M[3]*M[3]*M[3]*A[3]; } double _tijk_3o2d_sym_s_form_d ( const double *A, const double *v ) { return A[0]*v[0]*v[0]*v[0]+3*A[1]*v[0]*v[0]*v[1]+ 3*A[2]*v[0]*v[1]*v[1]+A[3]*v[1]*v[1]*v[1]; } float _tijk_3o2d_sym_s_form_f ( const float *A, const float *v ) { return A[0]*v[0]*v[0]*v[0]+3*A[1]*v[0]*v[0]*v[1]+ 3*A[2]*v[0]*v[1]*v[1]+A[3]*v[1]*v[1]*v[1]; } double _tijk_3o2d_sym_mean_d ( const double *A ) { ( void ) A; /* odd order; mean is zero irrespective of coefficients */ return 0; } float _tijk_3o2d_sym_mean_f ( const float *A ) { ( void ) A; /* odd order; mean is zero irrespective of coefficients */ return 0; } double _tijk_3o2d_sym_var_d ( const double *A ) { return ( 5*( A[0]*A[0]+A[3]*A[3] )+9*( A[1]*A[1]+A[2]*A[2] )+ 6*( A[0]*A[2]+A[1]*A[3] ) )/16.0; } float _tijk_3o2d_sym_var_f ( const float *A ) { return ( 5*( A[0]*A[0]+A[3]*A[3] )+9*( A[1]*A[1]+A[2]*A[2] )+ 6*( A[0]*A[2]+A[1]*A[3] ) )/16.0; } void _tijk_3o2d_sym_v_form_d ( double *res, const double *A, const double *v ) { double v00=v[0]*v[0], v01=v[0]*v[1], v11=v[1]*v[1]; res[0]=A[0]*v00+2*A[1]*v01+A[2]*v11; res[1]=A[1]*v00+2*A[2]*v01+A[3]*v11; } void _tijk_3o2d_sym_v_form_f ( float *res, const float *A, const float *v ) { float v00=v[0]*v[0], v01=v[0]*v[1], v11=v[1]*v[1]; res[0]=A[0]*v00+2*A[1]*v01+A[2]*v11; res[1]=A[1]*v00+2*A[2]*v01+A[3]*v11; } void _tijk_3o2d_sym_m_form_d ( double *res, const double *A, const double *v ) { res[0]=A[0]*v[0]+A[1]*v[1]; res[1]=A[1]*v[0]+A[2]*v[1]; res[2]=A[2]*v[0]+A[3]*v[1]; } void _tijk_3o2d_sym_m_form_f ( float *res, const float *A, const float *v ) { res[0]=A[0]*v[0]+A[1]*v[1]; res[1]=A[1]*v[0]+A[2]*v[1]; res[2]=A[2]*v[0]+A[3]*v[1]; } void _tijk_3o2d_sym_make_rank1_d ( double *res, const double s, const double *v ) { res[0]=s*v[0]*v[0]*v[0]; res[1]=s*v[0]*v[0]*v[1]; res[2]=s*v[0]*v[1]*v[1]; res[3]=s*v[1]*v[1]*v[1]; } void _tijk_3o2d_sym_make_rank1_f ( float *res, const float s, const float *v ) { res[0]=s*v[0]*v[0]*v[0]; res[1]=s*v[0]*v[0]*v[1]; res[2]=s*v[0]*v[1]*v[1]; res[3]=s*v[1]*v[1]*v[1]; } #define _tijk_3o2d_sym_make_iso_d NULL #define _tijk_3o2d_sym_make_iso_f NULL void _tijk_3o2d_sym_grad_d ( double *res, const double *A, const double *v ) { double proj, projv[2]; _tijk_3o2d_sym_v_form_d ( res, A, v ); ELL_2V_SCALE( res, 3.0, res ); proj=ELL_2V_DOT( res, v ); ELL_2V_SCALE( projv, -proj, v ); ELL_2V_INCR( res, projv ); } void _tijk_3o2d_sym_grad_f ( float *res, const float *A, const float *v ) { float proj, projv[2]; _tijk_3o2d_sym_v_form_f ( res, A, v ); ELL_2V_SCALE( res, 3.0, res ); proj=ELL_2V_DOT( res, v ); ELL_2V_SCALE( projv, -proj, v ); ELL_2V_INCR( res, projv ); } void _tijk_3o2d_sym_hess_d ( double *res, const double *A, const double *v ) { double tang[2]; double hess[3], s; ELL_2V_SET( tang, v[1], -v[0] ); _tijk_3o2d_sym_m_form_d( hess, A, v ); s=6*_tijk_2o2d_sym_s_form_d( hess, tang )-3*_tijk_2o2d_sym_s_form_d( hess, v ); _tijk_2o2d_sym_make_rank1_d( res, s, tang ); } void _tijk_3o2d_sym_hess_f ( float *res, const float *A, const float *v ) { float tang[2]; float hess[3], s; ELL_2V_SET( tang, v[1], -v[0] ); _tijk_3o2d_sym_m_form_f( hess, A, v ); s=6*_tijk_2o2d_sym_s_form_f( hess, tang )-3*_tijk_2o2d_sym_s_form_f( hess, v ); _tijk_2o2d_sym_make_rank1_f( res, s, tang ); } TIJK_TYPE_SYM( 3o2d_sym, 3, 2, 4 ) /* 4th order 2D unsymmetric */ double _tijk_4o2d_unsym_tsp_d ( const double *A, const double *B ) { return ELL_4V_DOT( A, B )+ELL_4V_DOT( A+4, B+4 )+ ELL_4V_DOT( A+8, B+8 )+ELL_4V_DOT( A+12, B+12 ); } float _tijk_4o2d_unsym_tsp_f ( const float *A, const float *B ) { return ELL_4V_DOT( A, B )+ELL_4V_DOT( A+4, B+4 )+ ELL_4V_DOT( A+8, B+8 )+ELL_4V_DOT( A+12, B+12 ); } double _tijk_4o2d_unsym_norm_d ( const double *A ) { return sqrt( ELL_4V_DOT( A, A )+ELL_4V_DOT( A+4, A+4 )+ ELL_4V_DOT( A+8, A+8 )+ELL_4V_DOT( A+12, A+12 ) ); } float _tijk_4o2d_unsym_norm_f ( const float *A ) { return sqrt( ELL_4V_DOT( A, A )+ELL_4V_DOT( A+4, A+4 )+ ELL_4V_DOT( A+8, A+8 )+ELL_4V_DOT( A+12, A+12 ) ); } #define _TIJK_4O2D_UNSYM_TRANS( TYPE, SUF ) \ void \ _tijk_4o2d_unsym_trans_##SUF ( TYPE *res, const TYPE *A, const TYPE *M ) \ { /* Tijkl = Mim Mjn Mko Mlp Tmnop \ * For efficiency, we transform mode by mode, right to left */ \ TYPE tmp[16]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; \ int i, init; \ for ( i=0; i<16; i+=2 ) { /* 4th mode */ \ tmp[i] = M[0]*A[i] + M[1]*A[i+1]; \ tmp[i+1]= M[2]*A[i] + M[3]*A[i+1]; \ } \ /* using res as additional tmp space */ \ for ( init=0; init<2; init++ ) { /* 3rd mode */ \ for ( i=init; i<16; i+=4 ) { \ res[i] = M[0]*tmp[i] + M[1]*tmp[i+2]; \ res[i+2]= M[2]*tmp[i] + M[3]*tmp[i+2]; \ } \ } \ for ( init=0; init<4; init++ ) { /* 2nd mode */ \ for ( i=init; i<16; i+=8 ) { \ tmp[i] = M[0]*res[i] + M[1]*res[i+4]; \ tmp[i+4]= M[2]*res[i] + M[3]*res[i+4]; \ } \ } \ for ( i=0; i<8; i++ ) { /* 1st mode */ \ res[i] = M[0]*tmp[i] + M[1]*tmp[i+8]; \ res[i+8]= M[2]*tmp[i] + M[3]*tmp[i+8]; \ } \ } _TIJK_4O2D_UNSYM_TRANS( double, d ) _TIJK_4O2D_UNSYM_TRANS( float, f ) #define _TIJK_4O2D_UNSYM_CONVERT( TYPE, SUF ) \ int \ _tijk_4o2d_unsym_convert_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_4o2d_unsym ) { /* copy over */ \ ELL_4V_COPY( res, A ); ELL_4V_COPY( res+4, A+4 ); \ ELL_4V_COPY( res+8, A+8 ); ELL_4V_COPY( res+12, A+12 ); \ return 0; \ } else if ( NULL!=res_type->_convert_from_##SUF ) \ return ( *res_type->_convert_from_##SUF )( res, A, tijk_4o2d_unsym ); \ else \ return 1; \ } _TIJK_4O2D_UNSYM_CONVERT( double, d ) _TIJK_4O2D_UNSYM_CONVERT( float, f ) #define _TIJK_4O2D_UNSYM_APPROX( TYPE, SUF ) \ int \ _tijk_4o2d_unsym_approx_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_4o2d_sym ) { \ res[0]=A[0]; res[1]=0.25*( A[1]+A[2]+A[4]+A[8] ); \ res[2]=( A[3]+A[5]+A[6]+A[9]+A[10]+A[12] )/6.0; \ res[3]=0.25*( A[7]+A[11]+A[13]+A[14] ); res[4]=A[15]; \ return 0; \ } else if ( NULL!=res_type->_approx_from_##SUF ) \ return ( *res_type->_approx_from_##SUF )( res, A, tijk_4o2d_unsym ); \ else \ return 1; \ } _TIJK_4O2D_UNSYM_APPROX( double, d ) _TIJK_4O2D_UNSYM_APPROX( float, f ) TIJK_TYPE_UNSYM( 4o2d_unsym, 4, 2, 16 ) /* 4th order 2D symmetric */ unsigned int _tijk_4o2d_sym_mult[5] = {1, 4, 6, 4, 1}; int _tijk_4o2d_sym_unsym2uniq[16] = {1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5}; int _tijk_4o2d_sym_uniq2unsym[16] = {1, 2, 3, 5, 9, 4, 6, 7, 10, 11, 13, 8, 12, 14, 15, 16}; unsigned int _tijk_4o2d_sym_uniq_idx[5] = {0, 1, 5, 11, 15}; #define _TIJK_4O2D_SYM_TSP( A, B ) \ ( ( A )[0]*( B )[0]+4*( A )[1]*( B )[1]+6*( A )[2]*( B )[2]+4*( A )[3]*( B )[3]+( A )[4]*( B )[4] ) double _tijk_4o2d_sym_tsp_d ( const double *A, const double *B ) { return _TIJK_4O2D_SYM_TSP( A, B ); } float _tijk_4o2d_sym_tsp_f ( const float *A, const float *B ) { return _TIJK_4O2D_SYM_TSP( A, B ); } double _tijk_4o2d_sym_norm_d ( const double *A ) { return sqrt( _TIJK_4O2D_SYM_TSP( A, A ) ); } float _tijk_4o2d_sym_norm_f ( const float *A ) { return sqrt( _TIJK_4O2D_SYM_TSP( A, A ) ); } #define _TIJK_4O2D_SYM_CONVERT( TYPE, SUF ) \ int \ _tijk_4o2d_sym_convert_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_4o2d_sym ) { /* copy over */ \ ELL_4V_COPY( res, A ); res[4]=A[4]; \ return 0; \ } else if ( res_type==tijk_4o2d_unsym ) { \ res[0]=A[0]; res[1]=res[2]=res[4]=res[8]=A[1]; \ res[3]=res[5]=res[6]=res[9]=res[10]=res[12]=A[2]; \ res[7]=res[11]=res[13]=res[14]=A[3]; res[15]=A[4]; \ return 0; \ } else if ( NULL!=res_type->_convert_from_##SUF ) \ return ( *res_type->_convert_from_##SUF )( res, A, tijk_4o2d_sym ); \ else \ return 1; \ } _TIJK_4O2D_SYM_CONVERT( double, d ) _TIJK_4O2D_SYM_CONVERT( float, f ) #define _TIJK_4O2D_SYM_APPROX( TYPE, SUF ) \ int \ _tijk_4o2d_sym_approx_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_2o2d_sym ) { \ res[0]=0.875*A[0]+0.75*A[2]-0.125*A[4]; \ res[1]=A[1]+A[3]; \ res[2]=-0.125*A[0]+0.75*A[2]+0.875*A[4]; \ return 0; \ } else if ( NULL!=res_type->_approx_from_##SUF ) \ return ( *res_type->_approx_from_##SUF )( res, A, tijk_4o2d_sym ); \ else \ return 1; \ } _TIJK_4O2D_SYM_APPROX( double, d ) _TIJK_4O2D_SYM_APPROX( float, f ) void _tijk_4o2d_sym_trans_d ( double *res, const double *A, const double *M ) { /* this code should be optimized at some point */ double tmp[16], tmpout[16]; _tijk_4o2d_sym_convert_d( tmp, tijk_4o2d_unsym, A ); _tijk_4o2d_unsym_trans_d( tmpout, tmp, M ); _tijk_4o2d_unsym_approx_d( res, tijk_4o2d_sym, tmpout ); } void _tijk_4o2d_sym_trans_f ( float *res, const float *A, const float *M ) { float tmp[16], tmpout[16]; _tijk_4o2d_sym_convert_f( tmp, tijk_4o2d_unsym, A ); _tijk_4o2d_unsym_trans_f( tmpout, tmp, M ); _tijk_4o2d_unsym_approx_f( res, tijk_4o2d_sym, tmpout ); } double _tijk_4o2d_sym_s_form_d ( const double *A, const double *v ) { double v00=v[0]*v[0], v01=v[0]*v[1], v11=v[1]*v[1]; return A[0]*v00*v00+4*A[1]*v00*v01+6*A[2]*v00*v11+ 4*A[3]*v01*v11+A[4]*v11*v11; } float _tijk_4o2d_sym_s_form_f ( const float *A, const float *v ) { float v00=v[0]*v[0], v01=v[0]*v[1], v11=v[1]*v[1]; return A[0]*v00*v00+4*A[1]*v00*v01+6*A[2]*v00*v11+ 4*A[3]*v01*v11+A[4]*v11*v11; } double _tijk_4o2d_sym_mean_d ( const double *A ) { return 0.375*( A[0]+A[4] )+0.75*A[2]; } float _tijk_4o2d_sym_mean_f ( const float *A ) { return 0.375*( A[0]+A[4] )+0.75*A[2]; } double _tijk_4o2d_sym_var_d ( const double *A ) { return A[0]*( 0.1328125*A[0]-0.09375*A[2]-0.234375*A[4] ) + A[1]*( 0.625*A[1]+0.75*A[3] ) + 0.28125*A[2]*A[2] + 0.625*A[3]*A[3] + A[4]*( 0.1328125*A[4]-0.09375*A[2] ); } float _tijk_4o2d_sym_var_f ( const float *A ) { return A[0]*( 0.1328125*A[0]-0.09375*A[2]-0.234375*A[4] ) + A[1]*( 0.625*A[1]+0.75*A[3] ) + 0.28125*A[2]*A[2] + 0.625*A[3]*A[3] + A[4]*( 0.1328125*A[4]-0.09375*A[2] ); } void _tijk_4o2d_sym_v_form_d ( double *res, const double *A, const double *v ) { double v000=v[0]*v[0]*v[0], v001=v[0]*v[0]*v[1], v011=v[0]*v[1]*v[1], v111=v[1]*v[1]*v[1]; res[0]=A[0]*v000+3*A[1]*v001+3*A[2]*v011+A[3]*v111; res[1]=A[1]*v000+3*A[2]*v001+3*A[3]*v011+A[4]*v111; } void _tijk_4o2d_sym_v_form_f ( float *res, const float *A, const float *v ) { float v000=v[0]*v[0]*v[0], v001=v[0]*v[0]*v[1], v011=v[0]*v[1]*v[1], v111=v[1]*v[1]*v[1]; res[0]=A[0]*v000+3*A[1]*v001+3*A[2]*v011+A[3]*v111; res[1]=A[1]*v000+3*A[2]*v001+3*A[3]*v011+A[4]*v111; } void _tijk_4o2d_sym_m_form_d ( double *res, const double *A, const double *v ) { double v00=v[0]*v[0], v01=v[0]*v[1], v11=v[1]*v[1]; res[0]=A[0]*v00+2*A[1]*v01+A[2]*v11; res[1]=A[1]*v00+2*A[2]*v01+A[3]*v11; res[2]=A[2]*v00+2*A[3]*v01+A[4]*v11; } void _tijk_4o2d_sym_m_form_f ( float *res, const float *A, const float *v ) { float v00=v[0]*v[0], v01=v[0]*v[1], v11=v[1]*v[1]; res[0]=A[0]*v00+2*A[1]*v01+A[2]*v11; res[1]=A[1]*v00+2*A[2]*v01+A[3]*v11; res[2]=A[2]*v00+2*A[3]*v01+A[4]*v11; } void _tijk_4o2d_sym_make_rank1_d ( double *res, const double s, const double *v ) { double v00=v[0]*v[0], v01=v[0]*v[1], v11=v[1]*v[1]; res[0]=s*v00*v00; res[1]=s*v00*v01; res[2]=s*v00*v11; res[3]=s*v01*v11; res[4]=s*v11*v11; } void _tijk_4o2d_sym_make_rank1_f ( float *res, const float s, const float *v ) { float v00=v[0]*v[0], v01=v[0]*v[1], v11=v[1]*v[1]; res[0]=s*v00*v00; res[1]=s*v00*v01; res[2]=s*v00*v11; res[3]=s*v01*v11; res[4]=s*v11*v11; } void _tijk_4o2d_sym_make_iso_d ( double *res, const double s ) { res[0]=res[4]=s; res[2]=s/3.0; res[1]=res[3]=0; } void _tijk_4o2d_sym_make_iso_f ( float *res, const float s ) { res[0]=res[4]=s; res[2]=s/3.0; res[1]=res[3]=0; } void _tijk_4o2d_sym_grad_d ( double *res, const double *A, const double *v ) { double proj, projv[2]; _tijk_4o2d_sym_v_form_d ( res, A, v ); ELL_2V_SCALE( res, 4.0, res ); proj=ELL_2V_DOT( res, v ); ELL_2V_SCALE( projv, -proj, v ); ELL_2V_INCR( res, projv ); } void _tijk_4o2d_sym_grad_f ( float *res, const float *A, const float *v ) { float proj, projv[2]; _tijk_4o2d_sym_v_form_f ( res, A, v ); ELL_2V_SCALE( res, 4.0, res ); proj=ELL_2V_DOT( res, v ); ELL_2V_SCALE( projv, -proj, v ); ELL_2V_INCR( res, projv ); } void _tijk_4o2d_sym_hess_d ( double *res, const double *A, const double *v ) { double tang[2]; double hess[3], s; ELL_2V_SET( tang, v[1], -v[0] ); _tijk_4o2d_sym_m_form_d( hess, A, v ); s=12*_tijk_2o2d_sym_s_form_d( hess, tang )-4*_tijk_2o2d_sym_s_form_d( hess, v ); _tijk_2o2d_sym_make_rank1_d( res, s, tang ); } void _tijk_4o2d_sym_hess_f ( float *res, const float *A, const float *v ) { float tang[2]; float hess[3], s; ELL_2V_SET( tang, v[1], -v[0] ); _tijk_4o2d_sym_m_form_f( hess, A, v ); s=12*_tijk_2o2d_sym_s_form_f( hess, tang )-4*_tijk_2o2d_sym_s_form_f( hess, v ); _tijk_2o2d_sym_make_rank1_f( res, s, tang ); } TIJK_TYPE_SYM( 4o2d_sym, 4, 2, 5 ) #include "convertQuietPop.h"

/Users/scm/git/github/teem/src/tijk/3dTijk.c

/* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2011, 2010, 2009, 2008 Thomas Schultz Copyright ( C ) 2010, 2009, 2008 Gordon Kindlmann This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /* Implementation of three-dimensional tensors */ #include "tijk.h" #include "privateTijk.h" #include "convertQuietPush.h" /* 1st order 3D - a simple vector */ /* ( un )symmetric doesn't really mean anything in this case */ unsigned int _tijk_1o3d_mult[3]={1, 1, 1}; int _tijk_1o3d_unsym2uniq[3] = {1, 2, 3}; int _tijk_1o3d_uniq2unsym[3] = {1, 2, 3}; unsigned int _tijk_1o3d_uniq_idx[3] = {0, 1, 2}; double 39 _tijk_1o3d_tsp_d ( const double *A, const double *B ) { return ELL_3V_DOT( A, B ); } float 44 _tijk_1o3d_tsp_f ( const float *A, const float *B ) { return ELL_3V_DOT( A, B ); } double 49 _tijk_1o3d_norm_d ( const double *A ) { return sqrt( ELL_3V_DOT( A, A ) ); } float 54 _tijk_1o3d_norm_f ( const float *A ) { return sqrt( ELL_3V_DOT( A, A ) ); } void 59 _tijk_1o3d_trans_d ( double *res, const double *A, const double *M ) { ell_3mv_mul_d( res, M, A ); } void 64 _tijk_1o3d_trans_f ( float *res, const float *A, const float *M ) { ell_3mv_mul_f( res, M, A ); } /* macro-based pseudo-template for type-generic code */ #define _TIJK_1O3D_CONVERT( TYPE, SUF ) \ 70 int \ _tijk_1o3d_convert_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_1o3d ) { /* copy over */ \ ELL_3V_COPY( res, A ); \ return 0; \ } else if ( res_type==tijk_3o3d_sym ) { \ res[0]=A[0]; res[1]=A[1]/3.0; res[2]=A[2]/3.0; \ res[3]=A[0]/3.0; res[4]=0; res[5]=A[0]/3.0; res[6]=A[1]; \ res[7]=A[2]/3.0; res[8]=A[1]/3.0; res[9]=A[2]; \ return 0; \ } else if ( NULL!=res_type->_convert_from_##SUF ) \ return ( *res_type->_convert_from_##SUF )( res, A, tijk_1o3d ); \ else \ return 1; \ } _TIJK_1O3D_CONVERT( double, d ) _TIJK_1O3D_CONVERT( float, f ) #define _TIJK_1O3D_APPROX( TYPE, SUF ) \ int \ _tijk_1o3d_approx_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( NULL!=res_type->_approx_from_##SUF ) \ return ( *res_type->_approx_from_##SUF )( res, A, tijk_1o3d ); \ else \ return 1; \ } _TIJK_1O3D_APPROX( double, d ) _TIJK_1O3D_APPROX( float, f ) double _tijk_1o3d_s_form_d ( const double *A, const double *v ) { return ELL_3V_DOT( A, v ); } float _tijk_1o3d_s_form_f ( const float *A, const float *v ) { return ELL_3V_DOT( A, v ); } double _tijk_1o3d_mean_d ( const double *A ) { ( void ) A; /* odd order; mean does not depend on coeffs */ return 0.0; } float _tijk_1o3d_mean_f ( const float *A ) { ( void ) A; /* odd order; mean does not depend on coeffs */ return 0.0f; } double _tijk_1o3d_var_d ( const double *A ) { /* result from MATHEMATICA */ return ELL_3V_DOT( A, A )/3.0; } float _tijk_1o3d_var_f ( const float *A ) { /* result from MATHEMATICA */ return ELL_3V_DOT( A, A )/3.0; } void _tijk_1o3d_v_form_d ( double *res, const double *A, const double *v ) { ( void ) v; /* not used in this case */ ELL_3V_COPY( res, A ); } void _tijk_1o3d_v_form_f ( float *res, const float *A, const float *v ) { ( void ) v; /* not used in this case */ ELL_3V_COPY( res, A ); } void _tijk_1o3d_m_form_d ( double *res, const double *A, const double *v ) { ( void ) A; ( void ) v; /* not used in this case */ ELL_3V_SET( res, 0, 0, 0 ); ELL_3V_SET( res+3, 0, 0, 0 ); } void _tijk_1o3d_m_form_f ( float *res, const float *A, const float *v ) { ( void ) A; ( void ) v; /* not used in this case */ ELL_3V_SET( res, 0, 0, 0 ); ELL_3V_SET( res+3, 0, 0, 0 ); } void _tijk_1o3d_make_rank1_d ( double *res, const double s, const double *v ) { ELL_3V_SCALE( res, s, v ); } void _tijk_1o3d_make_rank1_f ( float *res, const float s, const float *v ) { ELL_3V_SCALE( res, s, v ); } #define _tijk_1o3d_make_iso_d NULL #define _tijk_1o3d_make_iso_f NULL void _tijk_1o3d_grad_d ( double *res, const double *A, const double *v ) { ( void ) v; /* not used in this case */ ELL_3V_COPY( res, A ); } void _tijk_1o3d_grad_f ( float *res, const float *A, const float *v ) { ( void ) v; /* not used in this case */ ELL_3V_COPY( res, A ); } void _tijk_1o3d_hess_d ( double *res, const double *A, const double *v ) { ( void ) A; ( void ) v; /* not used in this case */ ELL_3V_SET( res, 0, 0, 0 ); ELL_3V_SET( res+3, 0, 0, 0 ); } void _tijk_1o3d_hess_f ( float *res, const float *A, const float *v ) { ( void ) A; ( void ) v; /* not used in this case */ ELL_3V_SET( res, 0, 0, 0 ); ELL_3V_SET( res+3, 0, 0, 0 ); } TIJK_TYPE_SYM( 1o3d, 1, 3, 3 ) /* 2nd order 3D unsymmetric */ double _tijk_2o3d_unsym_tsp_d ( const double *A, const double *B ) { return ELL_3V_DOT( A, B )+ELL_3V_DOT( A+3, B+3 )+ELL_3V_DOT( A+6, B+6 ); } float _tijk_2o3d_unsym_tsp_f ( const float *A, const float *B ) { return ELL_3V_DOT( A, B )+ELL_3V_DOT( A+3, B+3 )+ELL_3V_DOT( A+6, B+6 ); } double _tijk_2o3d_unsym_norm_d ( const double *A ) { return sqrt( ELL_3V_DOT( A, A )+ELL_3V_DOT( A+3, A+3 )+ELL_3V_DOT( A+6, A+6 ) ); } float _tijk_2o3d_unsym_norm_f ( const float *A ) { return sqrt( ELL_3V_DOT( A, A )+ELL_3V_DOT( A+3, A+3 )+ELL_3V_DOT( A+6, A+6 ) ); } void _tijk_2o3d_unsym_trans_d ( double *res, const double *A, const double *M ) { double _ma[9], _mt[9]; ELL_3M_MUL( _ma, M, A ); ELL_3M_TRANSPOSE( _mt, M ); ELL_3M_MUL( res, _ma, _mt ); } void _tijk_2o3d_unsym_trans_f ( float *res, const float *A, const float *M ) { float _ma[9], _mt[9]; ELL_3M_MUL( _ma, M, A ); ELL_3M_TRANSPOSE( _mt, M ); ELL_3M_MUL( res, _ma, _mt ); } /* macro-based pseudo-template for type-generic code */ #define _TIJK_2O3D_UNSYM_CONVERT( TYPE, SUF ) \ int \ _tijk_2o3d_unsym_convert_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_2o3d_unsym ) { /* copy over */ \ ELL_3M_COPY( res, A ); \ return 0; \ } else if ( NULL!=res_type->_convert_from_##SUF ) \ return ( *res_type->_convert_from_##SUF )( res, A, tijk_2o3d_unsym ); \ else \ return 1; \ } _TIJK_2O3D_UNSYM_CONVERT( double, d ) _TIJK_2O3D_UNSYM_CONVERT( float, f ) #define _TIJK_2O3D_UNSYM_APPROX( TYPE, SUF ) \ int \ _tijk_2o3d_unsym_approx_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_2o3d_sym ) { \ res[0]=A[0]; res[1]=0.5*( A[1]+A[3] ); res[2]=0.5*( A[2]+A[6] ); \ res[3]=A[4]; res[4]=0.5*( A[5]+A[7] ); res[5]=A[8]; \ return 0; \ } else if ( res_type==tijk_2o3d_asym ) { \ res[0]=0.5*( A[1]-A[3] ); res[1]=0.5*( A[2]-A[6] ); \ res[2]=0.5*( A[5]-A[7] ); \ return 0; \ } else if ( NULL!=res_type->_approx_from_##SUF ) \ return ( *res_type->_approx_from_##SUF )( res, A, tijk_2o3d_unsym ); \ else \ return 1; \ } _TIJK_2O3D_UNSYM_APPROX( double, d ) _TIJK_2O3D_UNSYM_APPROX( float, f ) TIJK_TYPE_UNSYM( 2o3d_unsym, 2, 3, 9 ) /* 2nd order 3D symmetric */ unsigned int _tijk_2o3d_sym_mult[6] = {1, 2, 2, 1, 2, 1}; int _tijk_2o3d_sym_unsym2uniq[9] = {1, 2, 3, 2, 4, 5, 3, 5, 6}; int _tijk_2o3d_sym_uniq2unsym[9] = {1, 2, 4, 3, 7, 5, 6, 7, 9}; unsigned int _tijk_2o3d_sym_uniq_idx[6] = {0, 1, 3, 5, 6, 8}; #define _TIJK_2O3D_SYM_TSP( A, B ) \ ( ( A )[0]*( B )[0]+2*( A )[1]*( B )[1]+2*( A )[2]*( B )[2]+ \ ( A )[3]*( B )[3]+2*( A )[4]*( B )[4]+( A )[5]*( B )[5] ) double _tijk_2o3d_sym_tsp_d ( const double *A, const double *B ) { return _TIJK_2O3D_SYM_TSP( A, B ); } float _tijk_2o3d_sym_tsp_f ( const float *A, const float *B ) { return _TIJK_2O3D_SYM_TSP( A, B ); } double _tijk_2o3d_sym_norm_d ( const double *A ) { return sqrt( _TIJK_2O3D_SYM_TSP( A, A ) ); } float _tijk_2o3d_sym_norm_f ( const float *A ) { return sqrt( _TIJK_2O3D_SYM_TSP( A, A ) ); } #define _TIJK_2O3D_SYM_CONVERT( TYPE, SUF ) \ int \ _tijk_2o3d_sym_convert_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_2o3d_sym ) { /* copy over */ \ ELL_3V_COPY( res, A ); ELL_3V_COPY( res+3, A+3 ); \ return 0; \ } else if ( res_type==tijk_2o3d_unsym ) { \ res[0]=A[0]; res[1]=res[3]=A[1]; res[2]=res[6]=A[2]; \ res[4]=A[3]; res[5]=res[7]=A[4]; res[8]=A[5]; \ return 0; \ } else if ( res_type==tijk_4o3d_sym || \ res_type==tijk_6o3d_sym ) { \ /* do this by going to SH and zero-padding */ \ TYPE tmp[28]; \ memset( tmp, 0, sizeof( tmp ) ); \ tijk_3d_sym_to_esh_##SUF ( tmp, A, tijk_2o3d_sym ); \ tijk_esh_to_3d_sym_##SUF ( res, tmp, res_type->order ); \ return 0; \ } else if ( NULL!=res_type->_convert_from_##SUF ) \ return ( *res_type->_convert_from_##SUF )( res, A, tijk_2o3d_sym ); \ return 1; \ } _TIJK_2O3D_SYM_CONVERT( double, d ) _TIJK_2O3D_SYM_CONVERT( float, f ) #define _TIJK_2O3D_SYM_APPROX( TYPE, SUF ) \ int \ _tijk_2o3d_sym_approx_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( NULL!=res_type->_approx_from_##SUF ) \ return ( *res_type->_approx_from_##SUF )( res, A, tijk_2o3d_sym ); \ else \ return 1; \ } _TIJK_2O3D_SYM_APPROX( double, d ) _TIJK_2O3D_SYM_APPROX( float, f ) void _tijk_2o3d_sym_trans_d ( double *res, const double *A, const double *M ) { /* this code could be optimized at some point */ double tmp[9], tmpout[9]; _tijk_2o3d_sym_convert_d( tmp, tijk_2o3d_unsym, A ); _tijk_2o3d_unsym_trans_d( tmpout, tmp, M ); _tijk_2o3d_unsym_approx_d( res, tijk_2o3d_sym, tmpout ); } void _tijk_2o3d_sym_trans_f ( float *res, const float *A, const float *M ) { /* this code could be optimized at some point */ float tmp[9], tmpout[9]; _tijk_2o3d_sym_convert_f( tmp, tijk_2o3d_unsym, A ); _tijk_2o3d_unsym_trans_f( tmpout, tmp, M ); _tijk_2o3d_unsym_approx_f( res, tijk_2o3d_sym, tmpout ); } double _tijk_2o3d_sym_s_form_d ( const double *A, const double *v ) { return A[0]*v[0]*v[0]+2*A[1]*v[0]*v[1]+2*A[2]*v[0]*v[2]+ A[3]*v[1]*v[1]+2*A[4]*v[1]*v[2]+A[5]*v[2]*v[2]; } float _tijk_2o3d_sym_s_form_f ( const float *A, const float *v ) { return A[0]*v[0]*v[0]+2*A[1]*v[0]*v[1]+2*A[2]*v[0]*v[2]+ A[3]*v[1]*v[1]+2*A[4]*v[1]*v[2]+A[5]*v[2]*v[2]; } double _tijk_2o3d_sym_mean_d ( const double *A ) { return ( A[0]+A[3]+A[5] )/3.0; } float _tijk_2o3d_sym_mean_f ( const float *A ) { return ( A[0]+A[3]+A[5] )/3.0f; } double _tijk_2o3d_sym_var_d ( const double *A ) { return 4.0/45.0*( A[0]*A[0]+A[3]*A[3]+A[5]*A[5]+ 3*( A[1]*A[1]+A[2]*A[2]+A[4]*A[4] )- A[3]*A[5]-A[0]*( A[3]+A[5] ) ); } float _tijk_2o3d_sym_var_f ( const float *A ) { return 4.0f/45.0f*( A[0]*A[0]+A[3]*A[3]+A[5]*A[5]+ 3.0f*( A[1]*A[1]+A[2]*A[2]+A[4]*A[4] )- A[3]*A[5]-A[0]*( A[3]+A[5] ) ); } void _tijk_2o3d_sym_v_form_d ( double *res, const double *A, const double *v ) { res[0]=A[0]*v[0]+A[1]*v[1]+A[2]*v[2]; res[1]=A[1]*v[0]+A[3]*v[1]+A[4]*v[2]; res[2]=A[2]*v[0]+A[4]*v[1]+A[5]*v[2]; } void _tijk_2o3d_sym_v_form_f ( float *res, const float *A, const float *v ) { res[0]=A[0]*v[0]+A[1]*v[1]+A[2]*v[2]; res[1]=A[1]*v[0]+A[3]*v[1]+A[4]*v[2]; res[2]=A[2]*v[0]+A[4]*v[1]+A[5]*v[2]; } void _tijk_2o3d_sym_m_form_d ( double *res, const double *A, const double *v ) { ( void ) v; /* v is only used in higher-order cases */ ELL_3V_COPY( res, A ); ELL_3V_COPY( res+3, A+3 ); } void _tijk_2o3d_sym_m_form_f ( float *res, const float *A, const float *v ) { ( void ) v; /* v is only used in higher-order cases */ ELL_3V_COPY( res, A ); ELL_3V_COPY( res+3, A+3 ); } void _tijk_2o3d_sym_make_rank1_d ( double *res, const double s, const double *v ) { res[0]=s*v[0]*v[0]; res[1]=s*v[0]*v[1]; res[2]=s*v[0]*v[2]; res[3]=s*v[1]*v[1]; res[4]=s*v[1]*v[2]; res[5]=s*v[2]*v[2]; } void _tijk_2o3d_sym_make_rank1_f ( float *res, const float s, const float *v ) { res[0]=s*v[0]*v[0]; res[1]=s*v[0]*v[1]; res[2]=s*v[0]*v[2]; res[3]=s*v[1]*v[1]; res[4]=s*v[1]*v[2]; res[5]=s*v[2]*v[2]; } void _tijk_2o3d_sym_make_iso_d ( double *res, const double s ) { res[0]=res[3]=res[5]=s; res[1]=res[2]=res[4]=0; } void _tijk_2o3d_sym_make_iso_f ( float *res, const float s ) { res[0]=res[3]=res[5]=s; res[1]=res[2]=res[4]=0; } void _tijk_2o3d_sym_grad_d ( double *res, const double *A, const double *v ) { double proj, projv[3]; res[0]=2*( A[0]*v[0]+A[1]*v[1]+A[2]*v[2] ); res[1]=2*( A[1]*v[0]+A[3]*v[1]+A[4]*v[2] ); res[2]=2*( A[2]*v[0]+A[4]*v[1]+A[5]*v[2] ); proj=ELL_3V_DOT( res, v ); ELL_3V_SCALE( projv, -proj, v ); ELL_3V_INCR( res, projv ); } void _tijk_2o3d_sym_grad_f ( float *res, const float *A, const float *v ) { float proj, projv[3]; res[0]=2.0f*( A[0]*v[0]+A[1]*v[1]+A[2]*v[2] ); res[1]=2.0f*( A[1]*v[0]+A[3]*v[1]+A[4]*v[2] ); res[2]=2.0f*( A[2]*v[0]+A[4]*v[1]+A[5]*v[2] ); proj=ELL_3V_DOT( res, v ); ELL_3V_SCALE( projv, -proj, v ); ELL_3V_INCR( res, projv ); } #define _TIJK_2O3D_SYM_HESS( TYPE, SUF ) \ void \ _tijk_2o3d_sym_hess_##SUF ( TYPE *res, const TYPE *A, const TYPE *v ) { \ /* get two orthonormal tangents */ \ TYPE t[2][3], h[4], der, norm, tmp[6]; \ int r, c; \ ell_3v_perp_##SUF( t[0], v ); \ ELL_3V_NORM( t[0], t[0], norm ); \ ELL_3V_CROSS( t[1], v, t[0] ); \ ELL_3V_NORM( t[1], t[1], norm ); \ /* compute Hessian w.r.t. t1/t2 */ \ der=2*_tijk_2o3d_sym_s_form_##SUF( A, v ); /* first der in direction v*/ \ h[0]=2*_tijk_2o3d_sym_s_form_##SUF( A, t[0] )-der; \ h[1]=2*( A[0]*t[0][0]*t[1][0]+A[1]*t[0][0]*t[1][1]+A[2]*t[0][0]*t[1][2]+ \ A[1]*t[0][1]*t[1][0]+A[3]*t[0][1]*t[1][1]+A[4]*t[0][1]*t[1][2]+ \ A[2]*t[0][2]*t[1][0]+A[4]*t[0][2]*t[1][1]+A[5]*t[0][2]*t[1][2] ); \ h[2]=h[1]; \ h[3]=2*_tijk_2o3d_sym_s_form_##SUF( A, t[1] )-der; \ /* now turn this into a symmetric order-2 rank-2 3D tensor */ \ for ( r=0; r<2; r++ ) { \ for ( c=0; c<3; c++ ) { \ tmp[3*r+c]=h[2*r]*t[0][c]+h[2*r+1]*t[1][c]; \ } \ } \ res[0]=t[0][0]*tmp[0]+t[1][0]*tmp[3]; \ res[1]=t[0][0]*tmp[1]+t[1][0]*tmp[4]; \ res[2]=t[0][0]*tmp[2]+t[1][0]*tmp[5]; \ res[3]=t[0][1]*tmp[1]+t[1][1]*tmp[4]; \ res[4]=t[0][1]*tmp[2]+t[1][1]*tmp[5]; \ res[5]=t[0][2]*tmp[2]+t[1][2]*tmp[5]; \ } _TIJK_2O3D_SYM_HESS( double, d ) _TIJK_2O3D_SYM_HESS( float, f ) TIJK_TYPE_SYM( 2o3d_sym, 2, 3, 6 ) /* 2nd order 3D antisymmetric */ unsigned int _tijk_2o3d_asym_mult[3] = {2, 2, 2}; int _tijk_2o3d_asym_unsym2uniq[9] = {0, 1, 2, -1, 0, 3, -2, -3, 0}; int _tijk_2o3d_asym_uniq2unsym[6] = {2, -4, 3, -7, 6, -8}; unsigned int _tijk_2o3d_asym_uniq_idx[3] = {0, 2, 4}; double _tijk_2o3d_asym_tsp_d ( const double *A, const double *B ) { return 2*ELL_3V_DOT( A, B ); } float _tijk_2o3d_asym_tsp_f ( const float *A, const float *B ) { return 2*ELL_3V_DOT( A, B ); } double _tijk_2o3d_asym_norm_d ( const double *A ) { return sqrt( 2*ELL_3V_DOT( A, A ) ); } float _tijk_2o3d_asym_norm_f ( const float *A ) { return sqrt( 2*ELL_3V_DOT( A, A ) ); } #define _TIJK_2O3D_ASYM_CONVERT( TYPE, SUF ) \ int \ _tijk_2o3d_asym_convert_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_2o3d_asym ) { /* copy over */ \ ELL_3V_COPY( res, A ); \ return 0; \ } else if ( res_type==tijk_2o3d_unsym ) { \ res[0]=0; res[1]=A[0]; res[2]=A[1]; \ res[3]=-A[0]; res[4]=0; res[5]=A[2]; \ res[6]=-A[1]; res[7]=-A[2]; res[8]=0; \ return 0; \ } else if ( NULL!=res_type->_convert_from_##SUF ) \ return ( *res_type->_convert_from_##SUF )( res, A, tijk_2o3d_asym ); \ else \ return 1; \ } _TIJK_2O3D_ASYM_CONVERT( double, d ) _TIJK_2O3D_ASYM_CONVERT( float, f ) #define _TIJK_2O3D_ASYM_APPROX( TYPE, SUF ) \ int \ _tijk_2o3d_asym_approx_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( NULL!=res_type->_approx_from_##SUF ) \ return ( *res_type->_approx_from_##SUF )( res, A, tijk_2o3d_asym ); \ else \ return 1; \ } _TIJK_2O3D_ASYM_APPROX( double, d ) _TIJK_2O3D_ASYM_APPROX( float, f ) void _tijk_2o3d_asym_trans_d ( double *res, const double *A, const double *M ) { /* this code could be optimized at some point */ double tmp[9], tmpout[9]; _tijk_2o3d_asym_convert_d( tmp, tijk_2o3d_unsym, A ); _tijk_2o3d_unsym_trans_d( tmpout, tmp, M ); _tijk_2o3d_unsym_approx_d( res, tijk_2o3d_asym, tmpout ); } void _tijk_2o3d_asym_trans_f ( float *res, const float *A, const float *M ) { /* this code could be optimized at some point */ float tmp[9], tmpout[9]; _tijk_2o3d_asym_convert_f( tmp, tijk_2o3d_unsym, A ); _tijk_2o3d_unsym_trans_f( tmpout, tmp, M ); _tijk_2o3d_unsym_approx_f( res, tijk_2o3d_asym, tmpout ); } TIJK_TYPE( 2o3d_asym, 2, 3, 3 ) /* 3rd order 3D unsymmetric */ double _tijk_3o3d_unsym_tsp_d ( const double *A, const double *B ) { double retval=0; unsigned int i; for ( i=0; i<27; i++ ) retval+=( *A++ )*( *B++ ); return retval; } float _tijk_3o3d_unsym_tsp_f ( const float *A, const float *B ) { float retval=0; unsigned int i; for ( i=0; i<27; i++ ) retval+=( *A++ )*( *B++ ); return retval; } double _tijk_3o3d_unsym_norm_d ( const double *A ) { return sqrt( _tijk_3o3d_unsym_tsp_d( A, A ) ); } float _tijk_3o3d_unsym_norm_f ( const float *A ) { return sqrt( _tijk_3o3d_unsym_tsp_f( A, A ) ); } void _tijk_3o3d_unsym_trans_d ( double *res, const double *A, const double *M ) { double _tmp1[27], _tmp2[27]; unsigned int i, j, k; for ( i=0; i<3; i++ ) for ( j=0; j<3; j++ ) for ( k=0; k<3; k++ ) _tmp1[3*( 3*i+j )+k]=M[3*k]*A[3*( 3*i+j )]+ M[3*k+1]*A[3*( 3*i+j )+1]+ M[3*k+2]*A[3*( 3*i+j )+2]; for ( i=0; i<3; i++ ) for ( j=0; j<3; j++ ) for ( k=0; k<3; k++ ) _tmp2[3*( 3*i+j )+k]=M[3*j]*_tmp1[3*( 3*i )+k]+ M[3*j+1]*_tmp1[3*( 3*i+1 )+k]+ M[3*j+2]*_tmp1[3*( 3*i+2 )+k]; for ( i=0; i<3; i++ ) for ( j=0; j<3; j++ ) for ( k=0; k<3; k++ ) res[3*( 3*i+j )+k]=M[3*i]*_tmp2[3*j+k]+ M[3*i+1]*_tmp2[3*( 3+j )+k]+ M[3*i+2]*_tmp2[3*( 6+j )+k]; } void _tijk_3o3d_unsym_trans_f ( float *res, const float *A, const float *M ) { float _tmp1[27], _tmp2[27]; unsigned int i, j, k; for ( i=0; i<3; i++ ) for ( j=0; j<3; j++ ) for ( k=0; k<3; k++ ) _tmp1[3*( 3*i+j )+k]=M[3*k]*A[3*( 3*i+j )]+ M[3*k+1]*A[3*( 3*i+j )+1]+ M[3*k+2]*A[3*( 3*i+j )+2]; for ( i=0; i<3; i++ ) for ( j=0; j<3; j++ ) for ( k=0; k<3; k++ ) _tmp2[3*( 3*i+j )+k]=M[3*j]*_tmp1[3*( 3*i )+k]+ M[3*j+1]*_tmp1[3*( 3*i+1 )+k]+ M[3*j+2]*_tmp1[3*( 3*i+2 )+k]; for ( i=0; i<3; i++ ) for ( j=0; j<3; j++ ) for ( k=0; k<3; k++ ) res[3*( 3*i+j )+k]=M[3*i]*_tmp2[3*j+k]+ M[3*i+1]*_tmp2[3*( 3+j )+k]+ M[3*i+2]*_tmp2[3*( 6+j )+k]; } #define _TIJK_3O3D_UNSYM_CONVERT( TYPE, SUF ) \ int \ _tijk_3o3d_unsym_convert_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_3o3d_unsym ) { /* copy over */ \ unsigned int i; \ for ( i=0; i<27; i++ ) \ ( *res++ )=( *A++ ); \ return 0; \ } else if ( NULL!=res_type->_convert_from_##SUF ) \ return ( *res_type->_convert_from_##SUF )( res, A, tijk_3o3d_unsym ); \ else \ return 1; \ } _TIJK_3O3D_UNSYM_CONVERT( double, d ) _TIJK_3O3D_UNSYM_CONVERT( float, f ) #define _TIJK_3O3D_UNSYM_APPROX( TYPE, SUF ) \ int \ _tijk_3o3d_unsym_approx_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_3o3d_sym ) { \ res[0]=A[0]; res[1]=( A[1]+A[3]+A[9] )/3.0; \ res[2]=( A[2]+A[6]+A[18] )/3.0; res[3]=( A[4]+A[10]+A[12] )/3.0; \ res[4]=( A[5]+A[7]+A[11]+A[15]+A[19]+A[21] )/6.0; \ res[5]=( A[8]+A[20]+A[24] )/3.0; res[6]=A[13]; \ res[7]=( A[14]+A[16]+A[25] )/3.0; res[8]=( A[17]+A[23]+A[25] )/3.0; \ res[9]=A[26]; \ return 0; \ } else if ( NULL!=res_type->_approx_from_##SUF ) \ return ( *res_type->_approx_from_##SUF )( res, A, tijk_3o3d_unsym ); \ else \ return 1; \ } _TIJK_3O3D_UNSYM_APPROX( double, d ) _TIJK_3O3D_UNSYM_APPROX( float, f ) TIJK_TYPE_UNSYM( 3o3d_unsym, 3, 3, 27 ) /* 3rd order 3D symmetric */ unsigned int _tijk_3o3d_sym_mult[10]={1, 3, 3, 3, 6, 3, 1, 3, 3, 1}; int _tijk_3o3d_sym_unsym2uniq[27] = {1, 2, 3, 2, 4, 5, 3, 5, 6, 2, 4, 5, 4, 7, 8, 5, 8, 9, 3, 5, 6, 5, 8, 9, 6, 9, 10}; int _tijk_3o3d_sym_uniq2unsym[27] = {1, 2, 4, 10, 3, 7, 19, 5, 11, 13, 6, 8, 12, 16, 20, 22, 9, 21, 25, 14, 15, 17, 23, 18, 24, 26, 27}; unsigned int _tijk_3o3d_sym_uniq_idx[10] = {0, 1, 4, 7, 10, 16, 19, 20, 23, 26}; #define _TIJK_3O3D_SYM_TSP( A, B ) \ ( ( A )[0]*( B )[0]+( A )[6]*( B )[6]+( A )[9]*( B )[9]+ \ 3*( ( A )[1]*( B )[1]+( A )[2]*( B )[2]+( A )[3]*( B )[3]+( A )[5]*( B )[5]+ \ ( A )[7]*( B )[7]+( A )[8]*( B )[8] )+ \ 6*( A )[4]*( B )[4] ) double _tijk_3o3d_sym_tsp_d ( const double *A, const double *B ) { return _TIJK_3O3D_SYM_TSP( A, B ); } float _tijk_3o3d_sym_tsp_f ( const float *A, const float *B ) { return _TIJK_3O3D_SYM_TSP( A, B ); } double _tijk_3o3d_sym_norm_d ( const double *A ) { return sqrt( _TIJK_3O3D_SYM_TSP( A, A ) ); } float _tijk_3o3d_sym_norm_f ( const float *A ) { return sqrt( _TIJK_3O3D_SYM_TSP( A, A ) ); } #define _TIJK_3O3D_SYM_CONVERT( TYPE, SUF ) \ int \ _tijk_3o3d_sym_convert_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_3o3d_sym ) { /* copy over */ \ tijk_copy_##SUF( res, A, tijk_3o3d_sym ); \ return 0; \ } else if ( res_type==tijk_3o3d_unsym ) { \ unsigned int i; \ for ( i=0; i<27; i++ ) { \ res[i]=A[_tijk_3o3d_sym_unsym2uniq[i]-1]; \ } \ return 0; \ } else if ( NULL!=res_type->_convert_from_##SUF ) \ return ( *res_type->_convert_from_##SUF )( res, A, tijk_3o3d_sym ); \ return 1; \ } _TIJK_3O3D_SYM_CONVERT( double, d ) _TIJK_3O3D_SYM_CONVERT( float, f ) #define _TIJK_3O3D_SYM_APPROX( TYPE, SUF ) \ int \ _tijk_3o3d_sym_approx_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ){ \ if ( res_type==tijk_1o3d ) { \ res[0]=0.6*( A[0]+A[3]+A[5] ); \ res[1]=0.6*( A[1]+A[6]+A[8] ); \ res[2]=0.6*( A[2]+A[7]+A[9] ); \ return 0; \ } else if ( NULL!=res_type->_approx_from_##SUF ) \ return ( *res_type->_approx_from_##SUF )( res, A, tijk_3o3d_sym ); \ else \ return 1; \ } _TIJK_3O3D_SYM_APPROX( double, d ) _TIJK_3O3D_SYM_APPROX( float, f ) void _tijk_3o3d_sym_trans_d ( double *res, const double *A, const double *M ) { /* this code could be optimized at some point */ double tmp[27], tmpout[27]; _tijk_3o3d_sym_convert_d( tmp, tijk_3o3d_unsym, A ); _tijk_3o3d_unsym_trans_d( tmpout, tmp, M ); _tijk_3o3d_unsym_approx_d( res, tijk_3o3d_sym, tmpout ); } void _tijk_3o3d_sym_trans_f ( float *res, const float *A, const float *M ) { /* this code could be optimized at some point */ float tmp[27], tmpout[27]; _tijk_3o3d_sym_convert_f( tmp, tijk_3o3d_unsym, A ); _tijk_3o3d_unsym_trans_f( tmpout, tmp, M ); _tijk_3o3d_unsym_approx_f( res, tijk_3o3d_sym, tmpout ); } double _tijk_3o3d_sym_s_form_d ( const double *A, const double *v ) { double v00=v[0]*v[0], v11=v[1]*v[1], v22=v[2]*v[2]; return A[0]*v00*v[0]+3*A[1]*v00*v[1]+3*A[2]*v00*v[2]+3*A[3]*v11*v[0]+ 6*A[4]*v[0]*v[1]*v[2]+3*A[5]*v22*v[0]+A[6]*v11*v[1]+3*A[7]*v11*v[2]+ 3*A[8]*v[1]*v22+A[9]*v22*v[2]; } float _tijk_3o3d_sym_s_form_f ( const float *A, const float *v ) { float v00=v[0]*v[0], v11=v[1]*v[1], v22=v[2]*v[2]; return A[0]*v00*v[0]+3*A[1]*v00*v[1]+3*A[2]*v00*v[2]+3*A[3]*v11*v[0]+ 6*A[4]*v[0]*v[1]*v[2]+3*A[5]*v22*v[0]+A[6]*v11*v[1]+3*A[7]*v11*v[2]+ 3*A[8]*v[1]*v22+A[9]*v22*v[2]; } double _tijk_3o3d_sym_mean_d ( const double *A ) { ( void ) A; /* odd order; mean does not depend on coeffs */ return 0.0; } float _tijk_3o3d_sym_mean_f ( const float *A ) { ( void ) A; /* odd order; mean does not depend on coeffs */ return 0.0f; } double _tijk_3o3d_sym_var_d ( const double *A ) { /* numerical result taken from MATHEMATICA */ return 1.0/35.0*( 5*( A[0]*A[0]+A[6]*A[6]+A[9]*A[9] )+ 6*( A[3]*A[5]+A[2]*( A[7]+A[9] )+A[6]*A[8]+A[0]*( A[3]+A[5] )+ A[1]*( A[6]+A[8] )+A[7]*A[9] )+ 9*( A[1]*A[1]+A[2]*A[2]+A[3]*A[3]+A[5]*A[5]+A[7]*A[7]+ A[8]*A[8] )+ 12*A[4]*A[4] ); } float _tijk_3o3d_sym_var_f ( const float *A ) { /* numerical result taken from MATHEMATICA */ return 1.0/35.0*( 5*( A[0]*A[0]+A[6]*A[6]+A[9]*A[9] )+ 6*( A[3]*A[5]+A[2]*( A[7]+A[9] )+A[6]*A[8]+A[0]*( A[3]+A[5] )+ A[1]*( A[6]+A[8] )+A[7]*A[9] )+ 9*( A[1]*A[1]+A[2]*A[2]+A[3]*A[3]+A[5]*A[5]+A[7]*A[7]+ A[8]*A[8] )+ 12*A[4]*A[4] ); } void _tijk_3o3d_sym_v_form_d ( double *res, const double *A, const double *v ) { double v00=v[0]*v[0], v01=v[0]*v[1], v02=v[0]*v[2], v11=v[1]*v[1], v12=v[1]*v[2], v22=v[2]*v[2]; res[0] = A[0]*v00+A[3]*v11+A[5]*v22+ 2*( A[1]*v01+A[2]*v02+A[4]*v12 ); res[1] = A[1]*v00+A[6]*v11+A[8]*v22+ 2*( A[3]*v01+A[4]*v02+A[7]*v12 ); res[2] = A[2]*v00+A[7]*v11+A[9]*v22+ 2*( A[4]*v01+A[5]*v02+A[8]*v12 ); } void _tijk_3o3d_sym_v_form_f ( float *res, const float *A, const float *v ) { float v00=v[0]*v[0], v01=v[0]*v[1], v02=v[0]*v[2], v11=v[1]*v[1], v12=v[1]*v[2], v22=v[2]*v[2]; res[0] = A[0]*v00+A[3]*v11+A[5]*v22+ 2*( A[1]*v01+A[2]*v02+A[4]*v12 ); res[1] = A[1]*v00+A[6]*v11+A[8]*v22+ 2*( A[3]*v01+A[4]*v02+A[7]*v12 ); res[2] = A[2]*v00+A[7]*v11+A[9]*v22+ 2*( A[4]*v01+A[5]*v02+A[8]*v12 ); } void _tijk_3o3d_sym_m_form_d ( double *res, const double *A, const double *v ) { res[0]=A[0]*v[0]+A[1]*v[1]+A[2]*v[2]; res[1]=A[1]*v[0]+A[3]*v[1]+A[4]*v[2]; res[2]=A[2]*v[0]+A[4]*v[1]+A[5]*v[2]; res[3]=A[3]*v[0]+A[6]*v[1]+A[7]*v[2]; res[4]=A[4]*v[0]+A[7]*v[1]+A[8]*v[2]; res[5]=A[5]*v[0]+A[8]*v[1]+A[9]*v[2]; } void _tijk_3o3d_sym_m_form_f ( float *res, const float *A, const float *v ) { res[0]=A[0]*v[0]+A[1]*v[1]+A[2]*v[2]; res[1]=A[1]*v[0]+A[3]*v[1]+A[4]*v[2]; res[2]=A[2]*v[0]+A[4]*v[1]+A[5]*v[2]; res[3]=A[3]*v[0]+A[6]*v[1]+A[7]*v[2]; res[4]=A[4]*v[0]+A[7]*v[1]+A[8]*v[2]; res[5]=A[5]*v[0]+A[8]*v[1]+A[9]*v[2]; } void _tijk_3o3d_sym_make_rank1_d ( double *res, const double s, const double *v ) { double v00=v[0]*v[0], v11=v[1]*v[1], v22=v[2]*v[2]; res[0]=s*v00*v[0]; res[1]=s*v00*v[1]; res[2]=s*v00*v[2]; res[3]=s*v[0]*v11; res[4]=s*v[0]*v[1]*v[2]; res[5]=s*v[0]*v22; res[6]=s*v[1]*v11; res[7]=s*v11*v[2]; res[8]=s*v[1]*v22; res[9]=s*v[2]*v22; } void _tijk_3o3d_sym_make_rank1_f ( float *res, const float s, const float *v ) { float v00=v[0]*v[0], v11=v[1]*v[1], v22=v[2]*v[2]; res[0]=s*v00*v[0]; res[1]=s*v00*v[1]; res[2]=s*v00*v[2]; res[3]=s*v[0]*v11; res[4]=s*v[0]*v[1]*v[2]; res[5]=s*v[0]*v22; res[6]=s*v[1]*v11; res[7]=s*v11*v[2]; res[8]=s*v[1]*v22; res[9]=s*v[2]*v22; } #define _tijk_3o3d_sym_make_iso_d NULL #define _tijk_3o3d_sym_make_iso_f NULL void _tijk_3o3d_sym_grad_d ( double *res, const double *A, const double *v ) { double proj, projv[3]; _tijk_3o3d_sym_v_form_d ( res, A, v ); ELL_3V_SCALE( res, 3.0, res ); proj=ELL_3V_DOT( res, v ); ELL_3V_SCALE( projv, -proj, v ); ELL_3V_INCR( res, projv ); } void _tijk_3o3d_sym_grad_f ( float *res, const float *A, const float *v ) { float proj, projv[3]; _tijk_3o3d_sym_v_form_f ( res, A, v ); ELL_3V_SCALE( res, 3.0, res ); proj=ELL_3V_DOT( res, v ); ELL_3V_SCALE( projv, -proj, v ); ELL_3V_INCR( res, projv ); } #define _TIJK_3O3D_SYM_HESS( TYPE, SUF ) \ void \ _tijk_3o3d_sym_hess_##SUF ( TYPE *res, const TYPE *A, const TYPE *v ) { \ /* get two orthonormal tangents */ \ TYPE t[2][3], cv[2][3], h[6], der, norm, tmp[6]; \ int r, c; \ ell_3v_perp_##SUF( t[0], v ); \ ELL_3V_NORM( t[0], t[0], norm ); \ ELL_3V_CROSS( t[1], v, t[0] ); \ ELL_3V_NORM( t[1], t[1], norm ); \ /* compute Hessian w.r.t. t1/t2 */ \ _tijk_3o3d_sym_m_form_##SUF( h, A, v ); \ der=3*_tijk_3o3d_sym_s_form_##SUF( A, v ); /* first der in direction v*/ \ _tijk_2o3d_sym_v_form_##SUF( cv[0], h, t[0] ); \ _tijk_2o3d_sym_v_form_##SUF( cv[1], h, t[1] ); \ h[0]=6*ELL_3V_DOT( cv[0], t[0] )-der; \ h[1]=6*ELL_3V_DOT( cv[0], t[1] ); \ h[2]=h[1]; \ h[3]=6*ELL_3V_DOT( cv[1], t[1] )-der; \ /* now turn this into a symmetric order-2 rank-2 3D tensor */ \ for ( r=0; r<2; r++ ) { \ for ( c=0; c<3; c++ ) { \ tmp[3*r+c]=h[2*r]*t[0][c]+h[2*r+1]*t[1][c]; \ } \ } \ res[0]=t[0][0]*tmp[0]+t[1][0]*tmp[3]; \ res[1]=t[0][0]*tmp[1]+t[1][0]*tmp[4]; \ res[2]=t[0][0]*tmp[2]+t[1][0]*tmp[5]; \ res[3]=t[0][1]*tmp[1]+t[1][1]*tmp[4]; \ res[4]=t[0][1]*tmp[2]+t[1][1]*tmp[5]; \ res[5]=t[0][2]*tmp[2]+t[1][2]*tmp[5]; \ } _TIJK_3O3D_SYM_HESS( double, d ) _TIJK_3O3D_SYM_HESS( float, f ) TIJK_TYPE_SYM( 3o3d_sym, 3, 3, 10 ) /* 4th order 3D symmetric */ /* ( unsymmetric counterpart currently not implemented ) */ unsigned int _tijk_4o3d_sym_mult[15]={1, 4, 4, 6, 12, 6, 4, 12, 12, 4, 1, 4, 6, 4, 1}; #define _tijk_4o3d_sym_unsym2uniq NULL #define _tijk_4o3d_sym_uniq2unsym NULL #define _tijk_4o3d_sym_uniq_idx NULL #define _TIJK_4O3D_SYM_TSP( A, B ) \ ( ( A )[0]*( B )[0]+( A )[10]*( B )[10]+( A )[14]*( B )[14]+ \ 4*( ( A )[1]*( B )[1]+( A )[2]*( B )[2]+( A )[6]*( B )[6]+( A )[9]*( B )[9]+ \ ( A )[11]*( B )[11]+( A )[13]*( B )[13] )+ \ 6*( ( A )[3]*( B )[3]+( A )[5]*( B )[5]+( A )[12]*( B )[12] )+ \ 12*( ( A )[4]*( B )[4]+( A )[7]*( B )[7]+( A )[8]*( B )[8] ) ) double _tijk_4o3d_sym_tsp_d ( const double *A, const double *B ) { return _TIJK_4O3D_SYM_TSP( A, B ); } float _tijk_4o3d_sym_tsp_f ( const float *A, const float *B ) { return _TIJK_4O3D_SYM_TSP( A, B ); } double _tijk_4o3d_sym_norm_d ( const double *A ) { return sqrt( _TIJK_4O3D_SYM_TSP( A, A ) ); } float _tijk_4o3d_sym_norm_f ( const float *A ) { return sqrt( _TIJK_4O3D_SYM_TSP( A, A ) ); } #define _TIJK_4O3D_SYM_TRANS( TYPE, SUF ) \ void \ _tijk_4o3d_sym_trans_##SUF ( TYPE *res, const TYPE *A, const TYPE *M ) { \ /* Tijkl = Mim Mjn Mko Mlp Tmnop \ * For efficiency, we transform mode by mode; the intermediate results \ * have incomplete symmetries! */ \ TYPE tmps[30], tmpl[36]; \ int i; \ { /* mode 4 */ \ int m[30]={0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6, 0, 3, 6}; \ int idx[90]={0, 1, 2, 0, 1, 2, 0, 1, 2, 1, 3, 4, 1, 3, 4, 1, 3, 4, 2, 4, 5, 2, 4, 5, 2, 4, 5, 3, 6, 7, 3, 6, 7, 3, 6, 7, 4, 7, 8, 4, 7, 8, 4, 7, 8, 5, 8, 9, 5, 8, 9, 5, 8, 9, 6, 10, 11, 6, 10, 11, 6, 10, 11, 7, 11, 12, 7, 11, 12, 7, 11, 12, 8, 12, 13, 8, 12, 13, 8, 12, 13, 9, 13, 14, 9, 13, 14, 9, 13, 14}; \ for ( i=0; i<30; i++ ) \ tmps[i]=M[m[i]]*A[idx[3*i]]+ \ M[m[i]+1]*A[idx[3*i+1]]+ \ M[m[i]+2]*A[idx[3*i+2]]; \ } \ { /* mode 3 */ \ int m[36]={0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6}; \ int idx[108]={0, 3, 6, 1, 4, 7, 2, 5, 8, 1, 4, 7, 2, 5, 8, 2, 5, 8, 3, 9, 12, 4, 10, 13, 5, 11, 14, 4, 10, 13, 5, 11, 14, 5, 11, 14, 6, 12, 15, 7, 13, 16, 8, 14, 17, 7, 13, 16, 8, 14, 17, 8, 14, 17, 9, 18, 21, 10, 19, 22, 11, 20, 23, 10, 19, 22, 11, 20, 23, 11, 20, 23, 12, 21, 24, 13, 22, 25, 14, 23, 26, 13, 22, 25, 14, 23, 26, 14, 23, 26, 15, 24, 27, 16, 25, 28, 17, 26, 29, 16, 25, 28, 17, 26, 29, 17, 26, 29}; \ for ( i=0; i<36; i++ ) \ tmpl[i]=M[m[i]]*tmps[idx[3*i]]+ \ M[m[i]+1]*tmps[idx[3*i+1]]+ \ M[m[i]+2]*tmps[idx[3*i+2]]; \ } \ { /* mode 2 */ \ int m[30]={0, 0, 0, 0, 0, 0, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 3, 3, 3, 6}; \ int idx[90]={0, 6, 12, 1, 7, 13, 2, 8, 14, 3, 9, 15, 4, 10, 16, 5, 11, 17, 3, 9, 15, 4, 10, 16, 5, 11, 17, 5, 11, 17, 6, 18, 24, 7, 19, 25, 8, 20, 26, 9, 21, 27, 10, 22, 28, 11, 23, 29, 9, 21, 27, 10, 22, 28, 11, 23, 29, 11, 23, 29, 12, 24, 30, 13, 25, 31, 14, 26, 32, 15, 27, 33, 16, 28, 34, 17, 29, 35, 15, 27, 33, 16, 28, 34, 17, 29, 35, 17, 29, 35}; \ for ( i=0; i<30; i++ ) \ tmps[i]=M[m[i]]*tmpl[idx[3*i]]+ \ M[m[i]+1]*tmpl[idx[3*i+1]]+ \ M[m[i]+2]*tmpl[idx[3*i+2]]; \ } \ { /* mode 1 */ \ int m[15]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 6}; \ int idx[45]={0, 10, 20, 1, 11, 21, 2, 12, 22, 3, 13, 23, 4, 14, 24, 5, 15, 25, 6, 16, 26, 7, 17, 27, 8, 18, 28, 9, 19, 29, 6, 16, 26, 7, 17, 27, 8, 18, 28, 9, 19, 29, 9, 19, 29}; \ for ( i=0; i<15; i++ ) \ res[i]=M[m[i]]*tmps[idx[3*i]]+ \ M[m[i]+1]*tmps[idx[3*i+1]]+ \ M[m[i]+2]*tmps[idx[3*i+2]]; \ } \ } _TIJK_4O3D_SYM_TRANS( double, d ) _TIJK_4O3D_SYM_TRANS( float, f ) #define _TIJK_4O3D_SYM_CONVERT( TYPE, SUF ) \ int \ _tijk_4o3d_sym_convert_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_4o3d_sym ) { /* copy over */ \ tijk_copy_##SUF( res, A, tijk_4o3d_sym ); \ return 0; \ } else if ( res_type==tijk_6o3d_sym ) { \ /* do this by going to SH and zero-padding */ \ TYPE tmp[28]; \ memset( tmp, 0, sizeof( tmp ) ); \ tijk_3d_sym_to_esh_##SUF ( tmp, A, tijk_4o3d_sym ); \ tijk_esh_to_3d_sym_##SUF ( res, tmp, res_type->order ); \ return 0; \ } else if ( NULL!=res_type->_convert_from_##SUF ) \ return ( *res_type->_convert_from_##SUF )( res, A, tijk_4o3d_sym ); \ return 1; \ } _TIJK_4O3D_SYM_CONVERT( double, d ) _TIJK_4O3D_SYM_CONVERT( float, f ) #define _TIJK_4O3D_SYM_APPROX( TYPE, SUF ) \ int \ _tijk_4o3d_sym_approx_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ){ \ if ( res_type==tijk_2o3d_sym ) { \ res[0]=3.0/35.0*( 9*A[0]+8*A[3]+8*A[5]-A[10]-A[14]-2*A[12] ); \ res[1]=6.0/7.0*( A[1]+A[6]+A[8] ); \ res[2]=6.0/7.0*( A[2]+A[9]+A[7] ); \ res[3]=3.0/35.0*( 9*A[10]+8*A[3]+8*A[12]-A[0]-A[14]-2*A[5] ); \ res[4]=6.0/7.0*( A[11]+A[13]+A[4] ); \ res[5]=3.0/35.0*( 9*A[14]+8*A[5]+8*A[12]-A[0]-A[10]-2*A[3] ); \ return 0; \ } else if ( NULL!=res_type->_approx_from_##SUF ) \ return ( *res_type->_approx_from_##SUF )( res, A, tijk_4o3d_sym ); \ else \ return 1; \ } _TIJK_4O3D_SYM_APPROX( double, d ) _TIJK_4O3D_SYM_APPROX( float, f ) double _tijk_4o3d_sym_s_form_d ( const double *A, const double *v ) { double v00=v[0]*v[0], v01=v[0]*v[1], v02=v[0]*v[2], v11=v[1]*v[1], v12=v[1]*v[2], v22=v[2]*v[2]; return A[0]*v00*v00+4*A[1]*v00*v01+4*A[2]*v00*v02+6*A[3]*v00*v11+ 12*A[4]*v00*v12+6*A[5]*v00*v22+4*A[6]*v01*v11+12*A[7]*v01*v12+ 12*A[8]*v01*v22+4*A[9]*v02*v22+A[10]*v11*v11+4*A[11]*v11*v12+ 6*A[12]*v11*v22+4*A[13]*v12*v22+A[14]*v22*v22; } float _tijk_4o3d_sym_s_form_f ( const float *A, const float *v ) { float v00=v[0]*v[0], v01=v[0]*v[1], v02=v[0]*v[2], v11=v[1]*v[1], v12=v[1]*v[2], v22=v[2]*v[2]; return A[0]*v00*v00+4*A[1]*v00*v01+4*A[2]*v00*v02+6*A[3]*v00*v11+ 12*A[4]*v00*v12+6*A[5]*v00*v22+4*A[6]*v01*v11+12*A[7]*v01*v12+ 12*A[8]*v01*v22+4*A[9]*v02*v22+A[10]*v11*v11+4*A[11]*v11*v12+ 6*A[12]*v11*v22+4*A[13]*v12*v22+A[14]*v22*v22; } double _tijk_4o3d_sym_mean_d ( const double *A ) { return 0.2*( A[0]+A[10]+A[14]+2*( A[3]+A[5]+A[12] ) ); } float _tijk_4o3d_sym_mean_f ( const float *A ) { return 0.2f*( A[0]+A[10]+A[14]+2.0f*( A[3]+A[5]+A[12] ) ); } double _tijk_4o3d_sym_var_d ( const double *A ) { /* numerical result taken from MATHEMATICA */ return 0.0795775*( -1.5319*( A[14]*A[3]+A[10]*A[5]+A[0]*A[12] ) -1.14893*( A[12]*A[3]+A[12]*A[5]+A[3]*A[5] ) -0.76595*( A[10]*A[14]+A[10]*A[0]+A[0]*A[14] ) +0.382975*( A[10]*A[12]+A[12]*A[14]+A[10]*A[3]+A[14]*A[5]+ A[0]*A[3]+A[0]*A[5] ) +0.893609*( A[0]*A[0]+A[10]*A[10]+A[14]*A[14] ) +2.29785*( A[12]*A[12] + A[3]*A[3] + A[5]*A[5] ) +3.19146*( A[1]*A[1]+A[2]*A[2]+A[11]*A[11]+A[13]*A[13]+ A[6]*A[6]+A[9]*A[9] ) +3.82975*( A[11]*A[13]+A[11]*A[4]+A[13]*A[4]+A[1]*A[6]+ A[2]*A[7]+A[1]*A[8]+A[6]*A[8]+A[2]*A[9]+ A[7]*A[9] ) +5.74463*( A[4]*A[4]+A[7]*A[7]+A[8]*A[8] ) ); } float _tijk_4o3d_sym_var_f ( const float *A ) { /* numerical result taken from MATHEMATICA */ return 0.0795775*( -1.5319*( A[14]*A[3]+A[10]*A[5]+A[0]*A[12] ) -1.14893*( A[12]*A[3]+A[12]*A[5]+A[3]*A[5] ) -0.76595*( A[10]*A[14]+A[10]*A[0]+A[0]*A[14] ) +0.382975*( A[10]*A[12]+A[12]*A[14]+A[10]*A[3]+A[14]*A[5]+ A[0]*A[3]+A[0]*A[5] ) +0.893609*( A[0]*A[0]+A[10]*A[10]+A[14]*A[14] ) +2.29785*( A[12]*A[12] + A[3]*A[3] + A[5]*A[5] ) +3.19146*( A[1]*A[1]+A[2]*A[2]+A[11]*A[11]+A[13]*A[13]+ A[6]*A[6]+A[9]*A[9] ) +3.82975*( A[11]*A[13]+A[11]*A[4]+A[13]*A[4]+A[1]*A[6]+ A[2]*A[7]+A[1]*A[8]+A[6]*A[8]+A[2]*A[9]+ A[7]*A[9] ) +5.74463*( A[4]*A[4]+A[7]*A[7]+A[8]*A[8] ) ); } void _tijk_4o3d_sym_v_form_d ( double *res, const double *A, const double *v ) { double v000=v[0]*v[0]*v[0], v001=v[0]*v[0]*v[1], v002=v[0]*v[0]*v[2], v011=v[0]*v[1]*v[1], v012=v[0]*v[1]*v[2], v022=v[0]*v[2]*v[2], v111=v[1]*v[1]*v[1], v112=v[1]*v[1]*v[2], v122=v[1]*v[2]*v[2], v222=v[2]*v[2]*v[2]; res[0] = A[0]*v000+A[6]*v111+A[9]*v222+6*A[4]*v012+ 3*( A[1]*v001+A[2]*v002+A[3]*v011+A[5]*v022+A[7]*v112+A[8]*v122 ); res[1] = A[1]*v000+A[10]*v111+A[13]*v222+6*A[7]*v012+ 3*( A[3]*v001+A[4]*v002+A[6]*v011+A[8]*v022+A[11]*v112+A[12]*v122 ); res[2] = A[2]*v000+A[11]*v111+A[14]*v222+6*A[8]*v012+ 3*( A[4]*v001+A[5]*v002+A[7]*v011+A[9]*v022+A[12]*v112+A[13]*v122 ); } void _tijk_4o3d_sym_v_form_f ( float *res, const float *A, const float *v ) { float v000=v[0]*v[0]*v[0], v001=v[0]*v[0]*v[1], v002=v[0]*v[0]*v[2], v011=v[0]*v[1]*v[1], v012=v[0]*v[1]*v[2], v022=v[0]*v[2]*v[2], v111=v[1]*v[1]*v[1], v112=v[1]*v[1]*v[2], v122=v[1]*v[2]*v[2], v222=v[2]*v[2]*v[2]; res[0] = A[0]*v000+A[6]*v111+A[9]*v222+6*A[4]*v012+ 3*( A[1]*v001+A[2]*v002+A[3]*v011+A[5]*v022+A[7]*v112+A[8]*v122 ); res[1] = A[1]*v000+A[10]*v111+A[13]*v222+6*A[7]*v012+ 3*( A[3]*v001+A[4]*v002+A[6]*v011+A[8]*v022+A[11]*v112+A[12]*v122 ); res[2] = A[2]*v000+A[11]*v111+A[14]*v222+6*A[8]*v012+ 3*( A[4]*v001+A[5]*v002+A[7]*v011+A[9]*v022+A[12]*v112+A[13]*v122 ); } void _tijk_4o3d_sym_m_form_d ( double *res, const double *A, const double *v ) { double v00=v[0]*v[0], v01=v[0]*v[1], v02=v[0]*v[2], v11=v[1]*v[1], v12=v[1]*v[2], v22=v[2]*v[2]; res[0]=A[0]*v00+A[3]*v11+A[5]*v22+2*( A[1]*v01+A[2]*v02+A[4]*v12 ); res[1]=A[1]*v00+A[6]*v11+A[8]*v22+2*( A[3]*v01+A[4]*v02+A[7]*v12 ); res[2]=A[2]*v00+A[7]*v11+A[9]*v22+2*( A[4]*v01+A[5]*v02+A[8]*v12 ); res[3]=A[3]*v00+A[10]*v11+A[12]*v22+2*( A[6]*v01+A[7]*v02+A[11]*v12 ); res[4]=A[4]*v00+A[11]*v11+A[13]*v22+2*( A[7]*v01+A[8]*v02+A[12]*v12 ); res[5]=A[5]*v00+A[12]*v11+A[14]*v22+2*( A[8]*v01+A[9]*v02+A[13]*v12 ); } void _tijk_4o3d_sym_m_form_f ( float *res, const float *A, const float *v ) { float v00=v[0]*v[0], v01=v[0]*v[1], v02=v[0]*v[2], v11=v[1]*v[1], v12=v[1]*v[2], v22=v[2]*v[2]; res[0]=A[0]*v00+A[3]*v11+A[5]*v22+2*( A[1]*v01+A[2]*v02+A[4]*v12 ); res[1]=A[1]*v00+A[6]*v11+A[8]*v22+2*( A[3]*v01+A[4]*v02+A[7]*v12 ); res[2]=A[2]*v00+A[7]*v11+A[9]*v22+2*( A[4]*v01+A[5]*v02+A[8]*v12 ); res[3]=A[3]*v00+A[10]*v11+A[12]*v22+2*( A[6]*v01+A[7]*v02+A[11]*v12 ); res[4]=A[4]*v00+A[11]*v11+A[13]*v22+2*( A[7]*v01+A[8]*v02+A[12]*v12 ); res[5]=A[5]*v00+A[12]*v11+A[14]*v22+2*( A[8]*v01+A[9]*v02+A[13]*v12 ); } void _tijk_4o3d_sym_make_rank1_d ( double *res, const double s, const double *v ) { double v00=v[0]*v[0], v01=v[0]*v[1], v02=v[0]*v[2], v11=v[1]*v[1], v12=v[1]*v[2], v22=v[2]*v[2]; res[0]=s*v00*v00; res[1]=s*v00*v01; res[2]=s*v00*v02; res[3]=s*v00*v11; res[4]=s*v00*v12; res[5]=s*v00*v22; res[6]=s*v01*v11; res[7]=s*v01*v12; res[8]=s*v01*v22; res[9]=s*v02*v22; res[10]=s*v11*v11; res[11]=s*v11*v12; res[12]=s*v11*v22; res[13]=s*v12*v22; res[14]=s*v22*v22; } void _tijk_4o3d_sym_make_rank1_f ( float *res, const float s, const float *v ) { float v00=v[0]*v[0], v01=v[0]*v[1], v02=v[0]*v[2], v11=v[1]*v[1], v12=v[1]*v[2], v22=v[2]*v[2]; res[0]=s*v00*v00; res[1]=s*v00*v01; res[2]=s*v00*v02; res[3]=s*v00*v11; res[4]=s*v00*v12; res[5]=s*v00*v22; res[6]=s*v01*v11; res[7]=s*v01*v12; res[8]=s*v01*v22; res[9]=s*v02*v22; res[10]=s*v11*v11; res[11]=s*v11*v12; res[12]=s*v11*v22; res[13]=s*v12*v22; res[14]=s*v22*v22; } void _tijk_4o3d_sym_make_iso_d ( double *res, const double s ) { res[0]=res[10]=res[14]=s; res[3]=res[5]=res[12]=s/3.0; res[1]=res[2]=res[4]=res[6]=res[7]=res[8]=res[9]=res[11]=res[13]=0.0; } void _tijk_4o3d_sym_make_iso_f ( float *res, const float s ) { res[0]=res[10]=res[14]=s; res[3]=res[5]=res[12]=s/3.0f; res[1]=res[2]=res[4]=res[6]=res[7]=res[8]=res[9]=res[11]=res[13]=0.0f; } void _tijk_4o3d_sym_grad_d ( double *res, const double *A, const double *v ) { double proj, projv[3]; _tijk_4o3d_sym_v_form_d ( res, A, v ); ELL_3V_SCALE( res, 4.0, res ); proj=ELL_3V_DOT( res, v ); ELL_3V_SCALE( projv, -proj, v ); ELL_3V_INCR( res, projv ); } void _tijk_4o3d_sym_grad_f ( float *res, const float *A, const float *v ) { float proj, projv[3]; _tijk_4o3d_sym_v_form_f ( res, A, v ); ELL_3V_SCALE( res, 4.0, res ); proj=ELL_3V_DOT( res, v ); ELL_3V_SCALE( projv, -proj, v ); ELL_3V_INCR( res, projv ); } #define _TIJK_4O3D_SYM_HESS( TYPE, SUF ) \ void \ _tijk_4o3d_sym_hess_##SUF ( TYPE *res, const TYPE *A, const TYPE *v ) { \ /* get two orthonormal tangents */ \ TYPE t[2][3], cv[2][3], h[6], der, norm, tmp[6]; \ int r, c; \ ell_3v_perp_##SUF( t[0], v ); \ ELL_3V_NORM( t[0], t[0], norm ); \ ELL_3V_CROSS( t[1], v, t[0] ); \ ELL_3V_NORM( t[1], t[1], norm ); \ /* compute Hessian w.r.t. t1/t2 */ \ _tijk_4o3d_sym_m_form_##SUF( h, A, v ); \ der=4*_tijk_4o3d_sym_s_form_##SUF( A, v ); /* first der in direction v*/ \ _tijk_2o3d_sym_v_form_##SUF( cv[0], h, t[0] ); \ _tijk_2o3d_sym_v_form_##SUF( cv[1], h, t[1] ); \ h[0]=12*ELL_3V_DOT( cv[0], t[0] )-der; \ h[1]=12*ELL_3V_DOT( cv[0], t[1] ); \ h[2]=h[1]; \ h[3]=12*ELL_3V_DOT( cv[1], t[1] )-der; \ /* now turn this into a symmetric order-2 rank-2 3D tensor */ \ for ( r=0; r<2; r++ ) { \ for ( c=0; c<3; c++ ) { \ tmp[3*r+c]=h[2*r]*t[0][c]+h[2*r+1]*t[1][c]; \ } \ } \ res[0]=t[0][0]*tmp[0]+t[1][0]*tmp[3]; \ res[1]=t[0][0]*tmp[1]+t[1][0]*tmp[4]; \ res[2]=t[0][0]*tmp[2]+t[1][0]*tmp[5]; \ res[3]=t[0][1]*tmp[1]+t[1][1]*tmp[4]; \ res[4]=t[0][1]*tmp[2]+t[1][1]*tmp[5]; \ res[5]=t[0][2]*tmp[2]+t[1][2]*tmp[5]; \ } _TIJK_4O3D_SYM_HESS( double, d ) _TIJK_4O3D_SYM_HESS( float, f ) TIJK_TYPE_SYM( 4o3d_sym, 4, 3, 15 ) /* 6th order 3D symmetric */ /* ( unsymmetric counterpart currently not implemented ) */ unsigned int _tijk_6o3d_sym_mult[28]={1, 6, 6, 15, 30, 15, 20, 60, 60, 20, 15, 60, 90, 60, 15, 6, 30, 60, 60, 30, 6, 1, 6, 15, 20, 15, 6, 1}; #define _tijk_6o3d_sym_unsym2uniq NULL #define _tijk_6o3d_sym_uniq2unsym NULL #define _tijk_6o3d_sym_uniq_idx NULL #define _TIJK_6O3D_SYM_TSP( A, B ) \ ( ( A )[0]*( B )[0]+( A )[21]*( B )[21]+( A )[27]*( B )[27]+ \ 6*( ( A )[1]*( B )[1]+( A )[2]*( B )[2]+( A )[15]*( B )[15]+( A )[20]*( B )[20]+ \ ( A )[22]*( B )[22]+( A )[26]*( B )[26] )+ \ 15*( ( A )[3]*( B )[3]+( A )[5]*( B )[5]+( A )[10]*( B )[10]+( A )[14]*( B )[14]+ \ ( A )[23]*( B )[23]+( A )[25]*( B )[25] )+ \ 30*( ( A )[4]*( B )[4]+( A )[16]*( B )[16]+( A )[19]*( B )[19] )+ \ 20*( ( A )[6]*( B )[6]+( A )[9]*( B )[9]+( A )[24]*( B )[24] )+ \ 60*( ( A )[7]*( B )[7]+( A )[8]*( B )[8]+( A )[11]*( B )[11]+ \ ( A )[13]*( B )[13]+( A )[17]*( B )[17]+( A )[18]*( B )[18] )+ \ 90*( A )[12]*( B )[12] ) \ double _tijk_6o3d_sym_tsp_d ( const double *A, const double *B ) { return _TIJK_6O3D_SYM_TSP( A, B ); } float _tijk_6o3d_sym_tsp_f ( const float *A, const float *B ) { return _TIJK_6O3D_SYM_TSP( A, B ); } double _tijk_6o3d_sym_norm_d ( const double *A ) { return sqrt( _TIJK_6O3D_SYM_TSP( A, A ) ); } float _tijk_6o3d_sym_norm_f ( const float *A ) { return sqrt( _TIJK_6O3D_SYM_TSP( A, A ) ); } #define _TIJK_6O3D_SYM_TRANS( TYPE, SUF ) \ void \ _tijk_6o3d_sym_trans_##SUF ( TYPE *res, const TYPE *A, const TYPE *M ) { \ /* Tijklmn = Mio Mjp Mkq Mlr Mms Mnt Topqrst \ * For efficiency, we transform mode by mode; the intermediate results \ * have incomplete symmetries! */ \ TYPE tmpl[100], tmpr[100]; \ int i; \ { /* mode 6 */ \ int m[3]={0, 3, 6}; \ int idx[189]={0, 1, 2, 0, 1, 2, 0, 1, 2, 1, 3, 4, 1, 3, 4, 1, 3, 4, 2, 4, 5, 2, 4, 5, 2, 4, 5, 3, 6, 7, 3, 6, 7, 3, 6, 7, 4, 7, 8, 4, 7, 8, 4, 7, 8, 5, 8, 9, 5, 8, 9, 5, 8, 9, 6, 10, 11, 6, 10, 11, 6, 10, 11, 7, 11, 12, 7, 11, 12, 7, 11, 12, 8, 12, 13, 8, 12, 13, 8, 12, 13, 9, 13, 14, 9, 13, 14, 9, 13, 14, 10, 15, 16, 10, 15, 16, 10, 15, 16, 11, 16, 17, 11, 16, 17, 11, 16, 17, 12, 17, 18, 12, 17, 18, 12, 17, 18, 13, 18, 19, 13, 18, 19, 13, 18, 19, 14, 19, 20, 14, 19, 20, 14, 19, 20, 15, 21, 22, 15, 21, 22, 15, 21, 22, 16, 22, 23, 16, 22, 23, 16, 22, 23, 17, 23, 24, 17, 23, 24, 17, 23, 24, 18, 24, 25, 18, 24, 25, 18, 24, 25, 19, 25, 26, 19, 25, 26, 19, 25, 26, 20, 26, 27, 20, 26, 27, 20, 26, 27}; \ for ( i=0; i<63; i++ ) \ tmpl[i]=M[m[i%3]]*A[idx[3*i]]+ \ M[m[i%3]+1]*A[idx[3*i+1]]+ \ M[m[i%3]+2]*A[idx[3*i+2]]; \ } \ { /* mode 5 */ \ int m[90]={0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6, 0, 0, 0, 3, 3, 6}; \ int idx[270]={0, 3, 6, 1, 4, 7, 2, 5, 8, 1, 4, 7, 2, 5, 8, 2, 5, 8, 3, 9, 12, 4, 10, 13, 5, 11, 14, 4, 10, 13, 5, 11, 14, 5, 11, 14, 6, 12, 15, 7, 13, 16, 8, 14, 17, 7, 13, 16, 8, 14, 17, 8, 14, 17, 9, 18, 21, 10, 19, 22, 11, 20, 23, 10, 19, 22, 11, 20, 23, 11, 20, 23, 12, 21, 24, 13, 22, 25, 14, 23, 26, 13, 22, 25, 14, 23, 26, 14, 23, 26, 15, 24, 27, 16, 25, 28, 17, 26, 29, 16, 25, 28, 17, 26, 29, 17, 26, 29, 18, 30, 33, 19, 31, 34, 20, 32, 35, 19, 31, 34, 20, 32, 35, 20, 32, 35, 21, 33, 36, 22, 34, 37, 23, 35, 38, 22, 34, 37, 23, 35, 38, 23, 35, 38, 24, 36, 39, 25, 37, 40, 26, 38, 41, 25, 37, 40, 26, 38, 41, 26, 38, 41, 27, 39, 42, 28, 40, 43, 29, 41, 44, 28, 40, 43, 29, 41, 44, 29, 41, 44, 30, 45, 48, 31, 46, 49, 32, 47, 50, 31, 46, 49, 32, 47, 50, 32, 47, 50, 33, 48, 51, 34, 49, 52, 35, 50, 53, 34, 49, 52, 35, 50, 53, 35, 50, 53, 36, 51, 54, 37, 52, 55, 38, 53, 56, 37, 52, 55, 38, 53, 56, 38, 53, 56, 39, 54, 57, 40, 55, 58, 41, 56, 59, 40, 55, 58, 41, 56, 59, 41, 56, 59, 42, 57, 60, 43, 58, 61, 44, 59, 62, 43, 58, 61, 44, 59, 62, 44, 59, 62}; \ for ( i=0; i<90; i++ ) \ tmpr[i]=M[m[i]]*tmpl[idx[3*i]]+ \ M[m[i]+1]*tmpl[idx[3*i+1]]+ \ M[m[i]+2]*tmpl[idx[3*i+2]]; \ } \ { /* mode 4 */ \ int m[100]={0, 0, 0, 0, 0, 0, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 3, 3, 3, 6}; \ int idx[300]={0, 6, 12, 1, 7, 13, 2, 8, 14, 3, 9, 15, 4, 10, 16, 5, 11, 17, 3, 9, 15, 4, 10, 16, 5, 11, 17, 5, 11, 17, 6, 18, 24, 7, 19, 25, 8, 20, 26, 9, 21, 27, 10, 22, 28, 11, 23, 29, 9, 21, 27, 10, 22, 28, 11, 23, 29, 11, 23, 29, 12, 24, 30, 13, 25, 31, 14, 26, 32, 15, 27, 33, 16, 28, 34, 17, 29, 35, 15, 27, 33, 16, 28, 34, 17, 29, 35, 17, 29, 35, 18, 36, 42, 19, 37, 43, 20, 38, 44, 21, 39, 45, 22, 40, 46, 23, 41, 47, 21, 39, 45, 22, 40, 46, 23, 41, 47, 23, 41, 47, 24, 42, 48, 25, 43, 49, 26, 44, 50, 27, 45, 51, 28, 46, 52, 29, 47, 53, 27, 45, 51, 28, 46, 52, 29, 47, 53, 29, 47, 53, 30, 48, 54, 31, 49, 55, 32, 50, 56, 33, 51, 57, 34, 52, 58, 35, 53, 59, 33, 51, 57, 34, 52, 58, 35, 53, 59, 35, 53, 59, 36, 60, 66, 37, 61, 67, 38, 62, 68, 39, 63, 69, 40, 64, 70, 41, 65, 71, 39, 63, 69, 40, 64, 70, 41, 65, 71, 41, 65, 71, 42, 66, 72, 43, 67, 73, 44, 68, 74, 45, 69, 75, 46, 70, 76, 47, 71, 77, 45, 69, 75, 46, 70, 76, 47, 71, 77, 47, 71, 77, 48, 72, 78, 49, 73, 79, 50, 74, 80, 51, 75, 81, 52, 76, 82, 53, 77, 83, 51, 75, 81, 52, 76, 82, 53, 77, 83, 53, 77, 83, 54, 78, 84, 55, 79, 85, 56, 80, 86, 57, 81, 87, 58, 82, 88, 59, 83, 89, 57, 81, 87, 58, 82, 88, 59, 83, 89, 59, 83, 89}; \ for ( i=0; i<100; i++ ) \ tmpl[i]=M[m[i]]*tmpr[idx[3*i]]+ \ M[m[i]+1]*tmpr[idx[3*i+1]]+ \ M[m[i]+2]*tmpr[idx[3*i+2]]; \ } \ { /* mode 3 */ \ int m[90]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 6}; \ int idx[270]={0, 10, 20, 1, 11, 21, 2, 12, 22, 3, 13, 23, 4, 14, 24, 5, 15, 25, 6, 16, 26, 7, 17, 27, 8, 18, 28, 9, 19, 29, 6, 16, 26, 7, 17, 27, 8, 18, 28, 9, 19, 29, 9, 19, 29, 10, 30, 40, 11, 31, 41, 12, 32, 42, 13, 33, 43, 14, 34, 44, 15, 35, 45, 16, 36, 46, 17, 37, 47, 18, 38, 48, 19, 39, 49, 16, 36, 46, 17, 37, 47, 18, 38, 48, 19, 39, 49, 19, 39, 49, 20, 40, 50, 21, 41, 51, 22, 42, 52, 23, 43, 53, 24, 44, 54, 25, 45, 55, 26, 46, 56, 27, 47, 57, 28, 48, 58, 29, 49, 59, 26, 46, 56, 27, 47, 57, 28, 48, 58, 29, 49, 59, 29, 49, 59, 30, 60, 70, 31, 61, 71, 32, 62, 72, 33, 63, 73, 34, 64, 74, 35, 65, 75, 36, 66, 76, 37, 67, 77, 38, 68, 78, 39, 69, 79, 36, 66, 76, 37, 67, 77, 38, 68, 78, 39, 69, 79, 39, 69, 79, 40, 70, 80, 41, 71, 81, 42, 72, 82, 43, 73, 83, 44, 74, 84, 45, 75, 85, 46, 76, 86, 47, 77, 87, 48, 78, 88, 49, 79, 89, 46, 76, 86, 47, 77, 87, 48, 78, 88, 49, 79, 89, 49, 79, 89, 50, 80, 90, 51, 81, 91, 52, 82, 92, 53, 83, 93, 54, 84, 94, 55, 85, 95, 56, 86, 96, 57, 87, 97, 58, 88, 98, 59, 89, 99, 56, 86, 96, 57, 87, 97, 58, 88, 98, 59, 89, 99, 59, 89, 99}; \ for ( i=0; i<90; i++ ) \ tmpr[i]=M[m[i]]*tmpl[idx[3*i]]+ \ M[m[i]+1]*tmpl[idx[3*i+1]]+ \ M[m[i]+2]*tmpl[idx[3*i+2]]; \ } \ { /* mode 2 */ \ int m[63]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 6}; \ int idx[189]={0, 15, 30, 1, 16, 31, 2, 17, 32, 3, 18, 33, 4, 19, 34, 5, 20, 35, 6, 21, 36, 7, 22, 37, 8, 23, 38, 9, 24, 39, 10, 25, 40, 11, 26, 41, 12, 27, 42, 13, 28, 43, 14, 29, 44, 10, 25, 40, 11, 26, 41, 12, 27, 42, 13, 28, 43, 14, 29, 44, 14, 29, 44, 15, 45, 60, 16, 46, 61, 17, 47, 62, 18, 48, 63, 19, 49, 64, 20, 50, 65, 21, 51, 66, 22, 52, 67, 23, 53, 68, 24, 54, 69, 25, 55, 70, 26, 56, 71, 27, 57, 72, 28, 58, 73, 29, 59, 74, 25, 55, 70, 26, 56, 71, 27, 57, 72, 28, 58, 73, 29, 59, 74, 29, 59, 74, 30, 60, 75, 31, 61, 76, 32, 62, 77, 33, 63, 78, 34, 64, 79, 35, 65, 80, 36, 66, 81, 37, 67, 82, 38, 68, 83, 39, 69, 84, 40, 70, 85, 41, 71, 86, 42, 72, 87, 43, 73, 88, 44, 74, 89, 40, 70, 85, 41, 71, 86, 42, 72, 87, 43, 73, 88, 44, 74, 89, 44, 74, 89}; \ for ( i=0; i<63; i++ ) \ tmpl[i]=M[m[i]]*tmpr[idx[3*i]]+ \ M[m[i]+1]*tmpr[idx[3*i+1]]+ \ M[m[i]+2]*tmpr[idx[3*i+2]]; \ } \ { /* mode 1 */ \ int m[28]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 6}; \ int idx[84]={0, 21, 42, 1, 22, 43, 2, 23, 44, 3, 24, 45, 4, 25, 46, 5, 26, 47, 6, 27, 48, 7, 28, 49, 8, 29, 50, 9, 30, 51, 10, 31, 52, 11, 32, 53, 12, 33, 54, 13, 34, 55, 14, 35, 56, 15, 36, 57, 16, 37, 58, 17, 38, 59, 18, 39, 60, 19, 40, 61, 20, 41, 62, 15, 36, 57, 16, 37, 58, 17, 38, 59, 18, 39, 60, 19, 40, 61, 20, 41, 62, 20, 41, 62}; \ for ( i=0; i<28; i++ ) \ res[i]=M[m[i]]*tmpl[idx[3*i]]+ \ M[m[i]+1]*tmpl[idx[3*i+1]]+ \ M[m[i]+2]*tmpl[idx[3*i+2]]; \ } \ } _TIJK_6O3D_SYM_TRANS( double, d ) _TIJK_6O3D_SYM_TRANS( float, f ) #define _TIJK_6O3D_SYM_CONVERT( TYPE, SUF ) \ int \ _tijk_6o3d_sym_convert_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ) { \ if ( res_type==tijk_6o3d_sym ) { /* copy over */ \ tijk_copy_##SUF( res, A, tijk_6o3d_sym ); \ return 0; \ } else if ( NULL!=res_type->_convert_from_##SUF ) \ return ( *res_type->_convert_from_##SUF )( res, A, tijk_6o3d_sym ); \ return 1; \ } _TIJK_6O3D_SYM_CONVERT( double, d ) _TIJK_6O3D_SYM_CONVERT( float, f ) #define _TIJK_6O3D_SYM_APPROX( TYPE, SUF ) \ int \ _tijk_6o3d_sym_approx_##SUF ( TYPE *res, const tijk_type *res_type, \ const TYPE *A ){ \ if ( res_type==tijk_2o3d_sym ) { \ /* do this in two steps */ \ TYPE tmp[15]; \ _tijk_6o3d_sym_approx_##SUF( tmp, tijk_4o3d_sym, A ); \ _tijk_4o3d_sym_approx_##SUF( res, tijk_2o3d_sym, tmp ); \ return 0; \ } else if ( res_type==tijk_4o3d_sym ) { \ res[0]=5.0/231.0*( 43*A[0]+A[21]+A[27]+24*( A[3]+A[5] )+ \ 3*( A[23]+A[25] )-18*( A[10]+A[14] )-36*A[12] ); \ res[1]=5.0/22.0*( 5*A[1]+4*( A[6]+A[8] )-A[15]-A[19]-2*A[17] ); \ res[2]=5.0/22.0*( 5*A[2]+4*( A[9]+A[7] )-A[20]-A[16]-2*A[18] ); \ res[3]=5.0/1386.0*( 321*( A[3]+A[10] )+306*A[12]-36*( A[5]+A[23] )- \ 19*( A[0]+A[21] )-15*( A[14]+A[25] )+2*A[27] ); \ res[4]=5.0/66.0*( 17*A[4]+16*( A[11]+A[13] )-A[22]-A[26]-2*A[24] ); \ res[5]=5.0/1386.0*( 321*( A[5]+A[14] )+306*A[12]-36*( A[3]+A[25] )- \ 19*( A[0]+A[27] )-15*( A[10]+A[23] )+2*A[21] ); \ res[6]=5.0/22.0*( 5*A[15]+4*( A[6]+A[17] )-A[1]-A[19]-2*A[8] ); \ res[7]=5.0/66.0*( 17*A[16]+16*( A[7]+A[18] )-A[2]-A[20]-2*A[9] ); \ res[8]=5.0/66.0*( 17*A[19]+16*( A[8]+A[17] )-A[1]-A[15]-2*A[6] ); \ res[9]=5.0/22.0*( 5*A[20]+4*( A[9]+A[18] )-A[2]-A[16]-2*A[7] ); \ res[10]=5.0/231.0*( 43*A[21]+A[0]+A[27]+24*( A[10]+A[23] )+ \ 3*( A[5]+A[14] )-18*( A[3]+A[25] )-36*A[12] ); \ res[11]=5.0/22.0*( 5*A[22]+4*( A[23]+A[11] )-A[26]-A[4]-2*A[13] ); \ res[12]=5.0/1386.0*( 312*( A[23]+A[25] )+306*A[12]-36*( A[10]+A[14] )- \ 19*( A[21]+A[27] )-15*( A[5]-A[3] )+2*A[0] ); \ res[13]=5.0/22.0*( 5*A[26]+4*( A[24]+A[13] )-A[22]-A[4]-2*A[11] ); \ res[14]=5.0/231.0*( 43*A[27]+A[0]+A[21]+24*( A[14]+A[25] )+ \ 3*( A[3]+A[10] )-18*( A[5]+A[23] )-36*A[12] ); \ return 0; \ } else if ( NULL!=res_type->_approx_from_##SUF ) \ return ( *res_type->_approx_from_##SUF )( res, A, tijk_6o3d_sym ); \ return 1; \ } _TIJK_6O3D_SYM_APPROX( double, d ) _TIJK_6O3D_SYM_APPROX( float, f ) double _tijk_6o3d_sym_s_form_d ( const double *A, const double *v ) { double v00=v[0]*v[0], v01=v[0]*v[1], v02=v[0]*v[2], v11=v[1]*v[1], v12=v[1]*v[2], v22=v[2]*v[2]; return A[0]*v00*v00*v00+ A[21]*v11*v11*v11+ A[27]*v22*v22*v22+ 6*( A[1]*v00*v00*v01+ A[2]*v00*v00*v02+ A[15]*v01*v11*v11+ A[20]*v02*v22*v22+ A[22]*v11*v11*v12+ A[26]*v12*v22*v22 )+ 15*( A[3]*v00*v00*v11+ A[5]*v00*v00*v22+ A[10]*v00*v11*v11+ A[14]*v00*v22*v22+ A[23]*v11*v11*v22+ A[25]*v11*v22*v22 )+ 30*( A[4]*v00*v00*v12+ A[16]*v01*v11*v12+ A[19]*v01*v22*v22 )+ 20*( A[6]*v00*v01*v11+ A[9]*v00*v02*v22+ A[24]*v11*v12*v22 )+ 60*( A[7]*v00*v01*v12+ A[8]*v00*v01*v22+ A[11]*v00*v11*v12+ A[13]*v00*v12*v22+ A[17]*v01*v11*v22+ A[18]*v01*v12*v22 )+ 90*A[12]*v00*v11*v22; } float _tijk_6o3d_sym_s_form_f ( const float *A, const float *v ) { float v00=v[0]*v[0], v01=v[0]*v[1], v02=v[0]*v[2], v11=v[1]*v[1], v12=v[1]*v[2], v22=v[2]*v[2]; return A[0]*v00*v00*v00+ A[21]*v11*v11*v11+ A[27]*v22*v22*v22+ 6*( A[1]*v00*v00*v01+ A[2]*v00*v00*v02+ A[15]*v01*v11*v11+ A[20]*v02*v22*v22+ A[22]*v11*v11*v12+ A[26]*v12*v22*v22 )+ 15*( A[3]*v00*v00*v11+ A[5]*v00*v00*v22+ A[10]*v00*v11*v11+ A[14]*v00*v22*v22+ A[23]*v11*v11*v22+ A[25]*v11*v22*v22 )+ 30*( A[4]*v00*v00*v12+ A[16]*v01*v11*v12+ A[19]*v01*v22*v22 )+ 20*( A[6]*v00*v01*v11+ A[9]*v00*v02*v22+ A[24]*v11*v12*v22 )+ 60*( A[7]*v00*v01*v12+ A[8]*v00*v01*v22+ A[11]*v00*v11*v12+ A[13]*v00*v12*v22+ A[17]*v01*v11*v22+ A[18]*v01*v12*v22 )+ 90*A[12]*v00*v11*v22; } double _tijk_6o3d_sym_mean_d ( const double *A ) { return ( A[0]+A[21]+A[27]+ 3*( A[3]+A[5]+A[10]+A[14]+A[23]+A[25] )+ 6*A[12] )/7.0; } float _tijk_6o3d_sym_mean_f ( const float *A ) { return ( A[0]+A[21]+A[27]+ 3*( A[3]+A[5]+A[10]+A[14]+A[23]+A[25] )+ 6*A[12] )/7.0; } double _tijk_6o3d_sym_var_d ( const double *A ) { double mean=( A[0]+A[21]+A[27]+ 3*( A[3]+A[5]+A[10]+A[14]+A[23]+A[25] )+ 6*A[12] )/7.0; return -mean*mean + ( 1.0/3003.0 )* ( + 10*A[21]*A[27] + 30*( A[14]*A[21]+A[27]*A[3] ) + 210*( A[21]*( A[3]+A[25] )+A[23]*A[27] ) + 231*( A[0]*A[0]+A[21]*A[21]+A[27]*A[27] ) + 270*A[25]*A[3] + 420*A[12]*( A[21]+A[27] ) + 450*( A[14]*( A[3]+A[23] )+A[23]*A[3] ) + 630*( A[21]*A[23]+A[14]*A[27]+A[25]*A[27] ) + 1050*A[14]*A[25] + 1575*( A[3]*A[3]+A[5]*A[5]+A[10]*A[10]+A[14]*A[14]+ A[23]*A[23]+A[25]*A[25] ) + 2250*A[23]*A[25] + 2700*A[12]*( A[3]+A[14]+A[23]+A[25] ) + 4860*A[12]*A[12] + 30*A[5]*( 90*A[12]+ 75*A[14]+ A[21]+ 9*A[23]+ 15*A[25]+ 7*A[27]+ 35*A[3] ) + 30*A[10]*( 90*A[12]+9*A[14]+21*A[21]+35*A[23]+15*A[25]+A[27]+75*A[3]+ 15*A[5] ) + 10*A[0]*( 21*A[10]+42*A[12]+21*A[14]+A[21]+3*A[23]+3*A[25]+A[27]+ 63*( A[3]+A[5] ) ) + 4*( +30*A[1]*( 3*A[15] + 6*A[17] + 3*A[19] + 14*( A[6] + A[8] ) ) +60*( A[8]*( 3*( A[15] + 6*A[17] + 5*A[19] ) + 10*A[6] )+ A[9]*( 3*A[16] + 10*A[18] + 7*( A[2] + A[20] ) + 10*A[7] )+ A[11]*( 18*A[13] + 7*A[22] + 10*A[24] + 3*A[26] + 15*A[4] )+ A[13]*( 3*A[22] + 10*A[24] + 7*A[26] + 15*A[4] )+ A[18]*( 3*A[2]+7*A[20]+18*A[7] ) ) +90*( A[2]*A[20]+A[15]*A[19]+A[22]*A[26]+ A[4]*( A[22]+2*A[24]+A[26] )+ A[16]*( 10*A[18]+A[2]+A[20]+10*A[7] ) ) +180*( A[20]*A[7]+A[19]*A[6] ) +189*( A[1]*A[1]+A[2]*A[2]+A[15]*A[15]+A[20]*A[20]+ A[22]*A[22]+A[26]*A[26] ) +420*( A[2]*A[7]+A[15]*A[17]+A[22]*A[24]+A[24]*A[26]+A[15]*A[6] ) +500*( A[9]*A[9]+A[24]*A[24]+A[6]*A[6] ) +525*( A[4]*A[4]+A[16]*A[16]+A[19]*A[19] ) +600*A[17]*A[6] +900*( A[7]*A[7]+A[8]*A[8]+A[11]*A[11]+A[13]*A[13]+A[17]*A[17]+ A[18]*A[18]+A[17]*A[19] ) ) ); } float _tijk_6o3d_sym_var_f ( const float *A ) { float mean=( A[0]+A[21]+A[27]+ 3*( A[3]+A[5]+A[10]+A[14]+A[23]+A[25] )+ 6*A[12] )/7.0; return -mean*mean + ( 1.0/3003.0 )* ( + 10*A[21]*A[27] + 30*( A[14]*A[21]+A[27]*A[3] ) + 210*( A[21]*( A[3]+A[25] )+A[23]*A[27] ) + 231*( A[0]*A[0]+A[21]*A[21]+A[27]*A[27] ) + 270*A[25]*A[3] + 420*A[12]*( A[21]+A[27] ) + 450*( A[14]*( A[3]+A[23] )+A[23]*A[3] ) + 630*( A[21]*A[23]+A[14]*A[27]+A[25]*A[27] ) + 1050*A[14]*A[25] + 1575*( A[3]*A[3]+A[5]*A[5]+A[10]*A[10]+A[14]*A[14]+ A[23]*A[23]+A[25]*A[25] ) + 2250*A[23]*A[25] + 2700*A[12]*( A[3]+A[14]+A[23]+A[25] ) + 4860*A[12]*A[12] + 30*A[5]*( 90*A[12]+ 75*A[14]+ A[21]+ 9*A[23]+ 15*A[25]+ 7*A[27]+ 35*A[3] ) + 30*A[10]*( 90*A[12]+9*A[14]+21*A[21]+35*A[23]+15*A[25]+A[27]+75*A[3]+ 15*A[5] ) + 10*A[0]*( 21*A[10]+42*A[12]+21*A[14]+A[21]+3*A[23]+3*A[25]+A[27]+ 63*( A[3]+A[5] ) ) + 4*( +30*A[1]*( 3*A[15] + 6*A[17] + 3*A[19] + 14*( A[6] + A[8] ) ) +60*( A[8]*( 3*( A[15] + 6*A[17] + 5*A[19] ) + 10*A[6] )+ A[9]*( 3*A[16] + 10*A[18] + 7*( A[2] + A[20] ) + 10*A[7] )+ A[11]*( 18*A[13] + 7*A[22] + 10*A[24] + 3*A[26] + 15*A[4] )+ A[13]*( 3*A[22] + 10*A[24] + 7*A[26] + 15*A[4] )+ A[18]*( 3*A[2]+7*A[20]+18*A[7] ) ) +90*( A[2]*A[20]+A[15]*A[19]+A[22]*A[26]+ A[4]*( A[22]+2*A[24]+A[26] )+ A[16]*( 10*A[18]+A[2]+A[20]+10*A[7] ) ) +180*( A[20]*A[7]+A[19]*A[6] ) +189*( A[1]*A[1]+A[2]*A[2]+A[15]*A[15]+A[20]*A[20]+ A[22]*A[22]+A[26]*A[26] ) +420*( A[2]*A[7]+A[15]*A[17]+A[22]*A[24]+A[24]*A[26]+A[15]*A[6] ) +500*( A[9]*A[9]+A[24]*A[24]+A[6]*A[6] ) +525*( A[4]*A[4]+A[16]*A[16]+A[19]*A[19] ) +600*A[17]*A[6] +900*( A[7]*A[7]+A[8]*A[8]+A[11]*A[11]+A[13]*A[13]+A[17]*A[17]+ A[18]*A[18]+A[17]*A[19] ) ) ); } #define _TIJK_6O3D_SYM_V_FORM( TYPE, SUF ) \ void \ _tijk_6o3d_sym_v_form_##SUF ( TYPE *res, const TYPE *A, const TYPE *v ) { \ TYPE v00=v[0]*v[0], v01=v[0]*v[1], v02=v[0]*v[2], \ v11=v[1]*v[1], v12=v[1]*v[2], v22=v[2]*v[2]; \ TYPE v00000=v00*v00*v[0], v00001=v00*v00*v[1], v00002=v00*v00*v[2], \ v00011=v00*v01*v[1], v00012=v00*v01*v[2], v00022=v00*v02*v[2], \ v00111=v00*v11*v[1], v00112=v00*v11*v[2], v00122=v00*v12*v[2], \ v00222=v00*v22*v[2], v01111=v01*v11*v[1], v01112=v01*v11*v[2], \ v01122=v01*v12*v[2], v01222=v01*v22*v[2], v02222=v02*v22*v[2], \ v11111=v11*v11*v[1], v11112=v11*v11*v[2], v11122=v11*v12*v[2], \ v11222=v11*v22*v[2], v12222=v12*v22*v[2], v22222=v22*v22*v[2]; \ res[0] = A[0]*v00000+ \ 5*A[1]*v00001+ \ 5*A[2]*v00002+ \ 10*A[3]*v00011+ \ 20*A[4]*v00012+ \ 10*A[5]*v00022+ \ 10*A[6]*v00111+ \ 30*A[7]*v00112+ \ 30*A[8]*v00122+ \ 10*A[9]*v00222+ \ 5*A[10]*v01111+ \ 20*A[11]*v01112+ \ 30*A[12]*v01122+ \ 20*A[13]*v01222+ \ 5*A[14]*v02222+ \ A[15]*v11111+ \ 5*A[16]*v11112+ \ 10*A[17]*v11122+ \ 10*A[18]*v11222+ \ 5*A[19]*v12222+ \ A[20]*v22222; \ res[1] = A[1]*v00000+ \ 5*A[3]*v00001+ \ 5*A[4]*v00002+ \ 10*A[6]*v00011+ \ 20*A[7]*v00012+ \ 10*A[8]*v00022+ \ 10*A[10]*v00111+ \ 30*A[11]*v00112+ \ 30*A[12]*v00122+ \ 10*A[13]*v00222+ \ 5*A[15]*v01111+ \ 20*A[16]*v01112+ \ 30*A[17]*v01122+ \ 20*A[18]*v01222+ \ 5*A[19]*v02222+ \ A[21]*v11111+ \ 5*A[22]*v11112+ \ 10*A[23]*v11122+ \ 10*A[24]*v11222+ \ 5*A[25]*v12222+ \ A[26]*v22222; \ res[2] = A[2]*v00000+ \ 5*A[4]*v00001+ \ 5*A[5]*v00002+ \ 10*A[7]*v00011+ \ 20*A[8]*v00012+ \ 10*A[9]*v00022+ \ 10*A[11]*v00111+ \ 30*A[12]*v00112+ \ 30*A[13]*v00122+ \ 10*A[14]*v00222+ \ 5*A[16]*v01111+ \ 20*A[17]*v01112+ \ 30*A[18]*v01122+ \ 20*A[19]*v01222+ \ 5*A[20]*v02222+ \ A[22]*v11111+ \ 5*A[23]*v11112+ \ 10*A[24]*v11122+ \ 10*A[25]*v11222+ \ 5*A[26]*v12222+ \ A[27]*v22222; \ } _TIJK_6O3D_SYM_V_FORM( double, d ) _TIJK_6O3D_SYM_V_FORM( float, f ) #define _TIJK_6O3D_SYM_M_FORM( TYPE, SUF ) \ void \ _tijk_6o3d_sym_m_form_##SUF ( TYPE *res, const TYPE *A, const TYPE *v ) { \ TYPE v00=v[0]*v[0], v01=v[0]*v[1], v02=v[0]*v[2], \ v11=v[1]*v[1], v12=v[1]*v[2], v22=v[2]*v[2]; \ TYPE v0000=v00*v00, v0001=v00*v01, v0002=v00*v02, v0011=v00*v11, \ v0012=v00*v12, v0022=v00*v22, v0111=v01*v11, v0112=v01*v12, \ v0122=v01*v22, v0222=v02*v22, v1111=v11*v11, v1112=v11*v12, \ v1122=v11*v22, v1222=v12*v22, v2222=v22*v22; \ res[0] = A[0]*v0000+ \ 4*A[1]*v0001+ \ 4*A[2]*v0002+ \ 6*A[3]*v0011+ \ 12*A[4]*v0012+ \ 6*A[5]*v0022+ \ 4*A[6]*v0111+ \ 12*A[7]*v0112+ \ 12*A[8]*v0122+ \ 4*A[9]*v0222+ \ A[10]*v1111+ \ 4*A[11]*v1112+ \ 6*A[12]*v1122+ \ 4*A[13]*v1222+ \ A[14]*v2222; \ res[1] = A[1]*v0000+ \ 4*A[3]*v0001+ \ 4*A[4]*v0002+ \ 6*A[6]*v0011+ \ 12*A[7]*v0012+ \ 6*A[8]*v0022+ \ 4*A[10]*v0111+ \ 12*A[11]*v0112+ \ 12*A[12]*v0122+ \ 4*A[13]*v0222+ \ A[15]*v1111+ \ 4*A[16]*v1112+ \ 6*A[17]*v1122+ \ 4*A[18]*v1222+ \ A[19]*v2222; \ res[2] = A[2]*v0000+ \ 4*A[4]*v0001+ \ 4*A[5]*v0002+ \ 6*A[7]*v0011+ \ 12*A[8]*v0012+ \ 6*A[9]*v0022+ \ 4*A[11]*v0111+ \ 12*A[12]*v0112+ \ 12*A[13]*v0122+ \ 4*A[14]*v0222+ \ A[16]*v1111+ \ 4*A[17]*v1112+ \ 6*A[18]*v1122+ \ 4*A[19]*v1222+ \ A[20]*v2222; \ res[3] = A[3]*v0000+ \ 4*A[6]*v0001+ \ 4*A[7]*v0002+ \ 6*A[10]*v0011+ \ 12*A[11]*v0012+ \ 6*A[12]*v0022+ \ 4*A[15]*v0111+ \ 12*A[16]*v0112+ \ 12*A[17]*v0122+ \ 4*A[18]*v0222+ \ A[21]*v1111+ \ 4*A[22]*v1112+ \ 6*A[23]*v1122+ \ 4*A[24]*v1222+ \ A[25]*v2222; \ res[4] = A[4]*v0000+ \ 4*A[7]*v0001+ \ 4*A[8]*v0002+ \ 6*A[11]*v0011+ \ 12*A[12]*v0012+ \ 6*A[13]*v0022+ \ 4*A[16]*v0111+ \ 12*A[17]*v0112+ \ 12*A[18]*v0122+ \ 4*A[19]*v0222+ \ A[22]*v1111+ \ 4*A[23]*v1112+ \ 6*A[24]*v1122+ \ 4*A[25]*v1222+ \ A[26]*v2222; \ res[5] = A[5]*v0000+ \ 4*A[8]*v0001+ \ 4*A[9]*v0002+ \ 6*A[12]*v0011+ \ 12*A[13]*v0012+ \ 6*A[14]*v0022+ \ 4*A[17]*v0111+ \ 12*A[18]*v0112+ \ 12*A[19]*v0122+ \ 4*A[20]*v0222+ \ A[23]*v1111+ \ 4*A[24]*v1112+ \ 6*A[25]*v1122+ \ 4*A[26]*v1222+ \ A[27]*v2222; \ } _TIJK_6O3D_SYM_M_FORM( double, d ) _TIJK_6O3D_SYM_M_FORM( float, f ) #define _TIJK_6O3D_SYM_MAKE_RANK1( TYPE, SUF ) \ void \ _tijk_6o3d_sym_make_rank1_##SUF ( TYPE *res, const TYPE s, const TYPE *v ) { \ TYPE v00=v[0]*v[0], v01=v[0]*v[1], v02=v[0]*v[2], \ v11=v[1]*v[1], v12=v[1]*v[2], v22=v[2]*v[2]; \ res[0]=s*v00*v00*v00; res[1]=s*v00*v00*v01; res[2]=s*v00*v00*v02; \ res[3]=s*v00*v00*v11; res[4]=s*v00*v00*v12; res[5]=s*v00*v00*v22; \ res[6]=s*v00*v01*v11; res[7]=s*v00*v01*v12; res[8]=s*v00*v01*v22; \ res[9]=s*v00*v02*v22; res[10]=s*v00*v11*v11; res[11]=s*v00*v11*v12; \ res[12]=s*v00*v11*v22; res[13]=s*v00*v12*v22; res[14]=s*v00*v22*v22; \ res[15]=s*v01*v11*v11; res[16]=s*v01*v11*v12; res[17]=s*v01*v11*v22; \ res[18]=s*v01*v12*v22; res[19]=s*v01*v22*v22; res[20]=s*v02*v22*v22; \ res[21]=s*v11*v11*v11; res[22]=s*v11*v11*v12; res[23]=s*v11*v11*v22; \ res[24]=s*v11*v12*v22; res[25]=s*v11*v22*v22; res[26]=s*v12*v22*v22; \ res[27]=s*v22*v22*v22; \ } _TIJK_6O3D_SYM_MAKE_RANK1( double, d ) _TIJK_6O3D_SYM_MAKE_RANK1( float, f ) void _tijk_6o3d_sym_make_iso_d ( double *res, const double s ) { /* initialize to zero, then set non-zero elements */ unsigned int i; for ( i=0; i<28; i++ ) res[i]=0; res[0]=res[21]=res[27]=s; res[3]=res[5]=res[10]=res[14]=res[23]=res[25]=0.2*s; res[12]=s/15.0; } void _tijk_6o3d_sym_make_iso_f ( float *res, const float s ) { /* initialize to zero, then set non-zero elements */ unsigned int i; for ( i=0; i<28; i++ ) res[i]=0; res[0]=res[21]=res[27]=s; res[3]=res[5]=res[10]=res[14]=res[23]=res[25]=0.2*s; res[12]=s/15.0; } void _tijk_6o3d_sym_grad_d ( double *res, const double *A, const double *v ) { double proj, projv[3]; _tijk_6o3d_sym_v_form_d ( res, A, v ); ELL_3V_SCALE( res, 6.0, res ); proj=ELL_3V_DOT( res, v ); ELL_3V_SCALE( projv, -proj, v ); ELL_3V_INCR( res, projv ); } void _tijk_6o3d_sym_grad_f ( float *res, const float *A, const float *v ) { float proj, projv[3]; _tijk_6o3d_sym_v_form_f ( res, A, v ); ELL_3V_SCALE( res, 6.0, res ); proj=ELL_3V_DOT( res, v ); ELL_3V_SCALE( projv, -proj, v ); ELL_3V_INCR( res, projv ); } #define _TIJK_6O3D_SYM_HESS( TYPE, SUF ) \ void \ _tijk_6o3d_sym_hess_##SUF ( TYPE *res, const TYPE *A, const TYPE *v ) { \ /* get two orthonormal tangents */ \ TYPE t[2][3], cv[2][3], h[6], der, norm, tmp[6]; \ int r, c; \ ell_3v_perp_##SUF( t[0], v ); \ ELL_3V_NORM( t[0], t[0], norm ); \ ELL_3V_CROSS( t[1], v, t[0] ); \ ELL_3V_NORM( t[1], t[1], norm ); \ /* compute Hessian w.r.t. t1/t2 */ \ _tijk_6o3d_sym_m_form_##SUF( h, A, v ); \ der=6*_tijk_6o3d_sym_s_form_##SUF( A, v ); /* first der in direction v*/ \ _tijk_2o3d_sym_v_form_##SUF( cv[0], h, t[0] ); \ _tijk_2o3d_sym_v_form_##SUF( cv[1], h, t[1] ); \ h[0]=30*ELL_3V_DOT( cv[0], t[0] )-der; \ h[1]=30*ELL_3V_DOT( cv[0], t[1] ); \ h[2]=h[1]; \ h[3]=30*ELL_3V_DOT( cv[1], t[1] )-der; \ /* now turn this into a symmetric order-2 rank-2 3D tensor */ \ for ( r=0; r<2; r++ ) { \ for ( c=0; c<3; c++ ) { \ tmp[3*r+c]=h[2*r]*t[0][c]+h[2*r+1]*t[1][c]; \ } \ } \ res[0]=t[0][0]*tmp[0]+t[1][0]*tmp[3]; \ res[1]=t[0][0]*tmp[1]+t[1][0]*tmp[4]; \ res[2]=t[0][0]*tmp[2]+t[1][0]*tmp[5]; \ res[3]=t[0][1]*tmp[1]+t[1][1]*tmp[4]; \ res[4]=t[0][1]*tmp[2]+t[1][1]*tmp[5]; \ res[5]=t[0][2]*tmp[2]+t[1][2]*tmp[5]; \ } _TIJK_6O3D_SYM_HESS( double, d ) _TIJK_6O3D_SYM_HESS( float, f ) TIJK_TYPE_SYM( 6o3d_sym, 6, 3, 28 ) /* 8th order 3D symmetric */ /* ( unsymmetric counterpart currently not implemented ) */ unsigned int _tijk_8o3d_sym_mult[45]={1, 8, 8, 28, 56, 28, 56, 168, 168, 56, 70, 280, 420, 280, 70, 56, 280, 560, 560, 280, 56, 28, 168, 420, 560, 420, 168, 28, 8, 56, 168, 280, 280, 168, 56, 8, 1, 8, 28, 56, 70, 56, 28, 8, 1}; #define _tijk_8o3d_sym_unsym2uniq NULL #define _tijk_8o3d_sym_uniq2unsym NULL #define _tijk_8o3d_sym_uniq_idx NULL double _tijk_8o3d_sym_tsp_d ( const double *A, const double *B ) { double retval=0.0; int i; for ( i=0; i<45; i++ ) { retval+=_tijk_8o3d_sym_mult[i]*A[i]*B[i]; } return retval; } float _tijk_8o3d_sym_tsp_f ( const float *A, const float *B ) { float retval=0.0; int i; for ( i=0; i<45; i++ ) { retval+=_tijk_8o3d_sym_mult[i]*A[i]*B[i]; } return retval; } double _tijk_8o3d_sym_norm_d ( const double *A ) { return sqrt( _tijk_8o3d_sym_tsp_d( A, A ) ); } float _tijk_8o3d_sym_norm_f ( const float *A ) { return sqrt( _tijk_8o3d_sym_tsp_f( A, A ) ); } #define _TIJK_8O3D_SYM_TRANS( TYPE, SUF ) \ void \ _tijk_8o3d_sym_trans_##SUF ( TYPE *res, const TYPE *A, const TYPE *M ) { \ /* Tijklmnop = Miq Mjr Mks Mlt Mmu Mnv Mow Mpx Tqrstuvwx \ * For efficiency, we transform mode by mode; the intermediate results \ * have incomplete symmetries! */ \ TYPE tmpl[225], tmpr[225]; \ int i; \ { /* mode 8: */ \ int m[108]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6}; \ int idx[324]={0, 1, 2, 1, 3, 4, 2, 4, 5, 3, 6, 7, 4, 7, 8, 5, 8, 9, 6, 10, 11, 7, 11, 12, 8, 12, 13, 9, 13, 14, 10, 15, 16, 11, 16, 17, 12, 17, 18, 13, 18, 19, 14, 19, 20, 15, 21, 22, 16, 22, 23, 17, 23, 24, 18, 24, 25, 19, 25, 26, 20, 26, 27, 21, 28, 29, 22, 29, 30, 23, 30, 31, 24, 31, 32, 25, 32, 33, 26, 33, 34, 27, 34, 35, 28, 36, 37, 29, 37, 38, 30, 38, 39, 31, 39, 40, 32, 40, 41, 33, 41, 42, 34, 42, 43, 35, 43, 44, 0, 1, 2, 1, 3, 4, 2, 4, 5, 3, 6, 7, 4, 7, 8, 5, 8, 9, 6, 10, 11, 7, 11, 12, 8, 12, 13, 9, 13, 14, 10, 15, 16, 11, 16, 17, 12, 17, 18, 13, 18, 19, 14, 19, 20, 15, 21, 22, 16, 22, 23, 17, 23, 24, 18, 24, 25, 19, 25, 26, 20, 26, 27, 21, 28, 29, 22, 29, 30, 23, 30, 31, 24, 31, 32, 25, 32, 33, 26, 33, 34, 27, 34, 35, 28, 36, 37, 29, 37, 38, 30, 38, 39, 31, 39, 40, 32, 40, 41, 33, 41, 42, 34, 42, 43, 35, 43, 44, 0, 1, 2, 1, 3, 4, 2, 4, 5, 3, 6, 7, 4, 7, 8, 5, 8, 9, 6, 10, 11, 7, 11, 12, 8, 12, 13, 9, 13, 14, 10, 15, 16, 11, 16, 17, 12, 17, 18, 13, 18, 19, 14, 19, 20, 15, 21, 22, 16, 22, 23, 17, 23, 24, 18, 24, 25, 19, 25, 26, 20, 26, 27, 21, 28, 29, 22, 29, 30, 23, 30, 31, 24, 31, 32, 25, 32, 33, 26, 33, 34, 27, 34, 35, 28, 36, 37, 29, 37, 38, 30, 38, 39, 31, 39, 40, 32, 40, 41, 33, 41, 42, 34, 42, 43, 35, 43, 44}; \ for ( i=0; i<108; i++ ) \ tmpl[i]=M[m[i]]*A[idx[3*i]]+ \ M[m[i]+1]*A[idx[3*i+1]]+ \ M[m[i]+2]*A[idx[3*i+2]]; \ } \ { /* mode 7: */ \ int m[168]={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6}; \

/Users/scm/git/github/teem/src/tijk/approxTijk.c

/Users/scm/git/github/teem/src/tijk/enumsTijk.c

/Users/scm/git/github/teem/src/tijk/miscTijk.c

1 /* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2010, 2009, 2008 Thomas Schultz Copyright ( C ) 2010, 2009, 2008 Gordon Kindlmann This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "tijk.h" const int tijkPresent = 42; /* Some basic component-wise operations that don't depend on tensor type */ void 32 tijk_add_d ( double *res, const double *A, const double *B, const tijk_type *type ) { unsigned int i; for ( i=0; i<type->num; i++ ) *( res++ )=*( A++ )+*( B++ ); } void 40 tijk_add_f ( float *res, const float *A, const float *B, const tijk_type *type ) { unsigned int i; for ( i=0; i<type->num; i++ ) *( res++ )=*( A++ )+*( B++ ); } void 48 tijk_sub_d ( double *res, const double *A, const double *B, const tijk_type *type ) { unsigned int i; for ( i=0; i<type->num; i++ ) *( res++ )=*( A++ )-*( B++ ); } void 56 tijk_sub_f ( float *res, const float *A, const float *B, const tijk_type *type ) { unsigned int i; for ( i=0; i<type->num; i++ ) *( res++ )=*( A++ )-*( B++ ); } void 64 tijk_incr_d ( double *res, const double *A, const tijk_type *type ) { unsigned int i; for ( i=0; i<type->num; i++ ) *( res++ )+=*( A++ ); } void 71 tijk_incr_f ( float *res, const float *A, const tijk_type *type ) { unsigned int i; for ( i=0; i<type->num; i++ ) *( res++ )+=*( A++ ); } void 78 tijk_negate_d ( double *res, const double *A, const tijk_type *type ) { unsigned int i; for ( i=0; i<type->num; i++ ) *( res++ )=-*( A++ ); } void 85 tijk_negate_f ( float *res, const float *A, const tijk_type *type ) { unsigned int i; for ( i=0; i<type->num; i++ ) *( res++ )=-*( A++ ); } void 92 tijk_scale_d ( double *res, const double s, const double *A, const tijk_type *type ) { unsigned int i; for ( i=0; i<type->num; i++ ) *( res++ )=s*( *A++ ); } void 100 tijk_scale_f ( float *res, const float s, const float *A, const tijk_type *type ) { unsigned int i; for ( i=0; i<type->num; i++ ) *( res++ )=s*( *A++ ); } void 108 tijk_zero_d ( double *res, const tijk_type *type ) { unsigned int i; for ( i=0; i<type->num; i++ ) *( res++ )=0.0; } void 115 tijk_zero_f ( float *res, const tijk_type *type ) { unsigned int i; for ( i=0; i<type->num; i++ ) *( res++ )=0.0; } void 122 tijk_copy_d ( double *res, const double *A, const tijk_type *type ) { unsigned int i; for ( i=0; i<type->num; i++ ) *( res++ )=*( A++ ); } void 129 tijk_copy_f ( float *res, const float *A, const tijk_type *type ) { unsigned int i; for ( i=0; i<type->num; i++ ) *( res++ )=*( A++ ); }

/Users/scm/git/github/teem/src/tijk/nrrdTijk.c

1 /* Teem: Tools to process and visualize scientific data and images . Copyright ( C ) 2011 Thomas Schultz This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License ( LGPL ) as published by the Free Software Foundation; either version 2.1 of the License, or ( at your option ) any later version. The terms of redistributing and/or modifying this software also include exceptions to the LGPL that facilitate static linking. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ /* Reading and setting axis labels to encode Tijk types */ #include "tijk.h" /* tijk_set_axis_tensor * * Marks a given nrrd axis as containing tensors of a given type * Based on axis size, determines if values are masked. * Returns 0 on success * 1 if given NULL pointer * 2 if nrrd has wrong type ( neither float nor double ) * 3 if axis doesn't exist * 4 if axis has wrong size */ 36 int tijk_set_axis_tensor( Nrrd *nrrd, unsigned int axis, const tijk_type *type ) { NrrdAxisInfo *axinfo = NULL; unsigned int masked = 0, lablen; if ( nrrd==NULL || type==NULL ) return 1; if ( nrrd->type!=nrrdTypeFloat && nrrd->type!=nrrdTypeDouble ) return 2; if ( axis>=nrrd->dim ) return 3; axinfo = nrrd->axis+axis; if ( axinfo->size==type->num+1 ) masked = 1; else if ( axinfo->size!=type->num ) return 4; axinfo->label = ( char* ) airFree( axinfo->label ); lablen = strlen( "tijk__" ) + strlen( type->name ) + ( masked?strlen( "mask_" ):0 ) + 1; axinfo->label = AIR_CALLOC( lablen, char ); sprintf( axinfo->label, "tijk_%s%s", masked?"mask_":"", type->name ); return 0; } /* tijk_set_axis_esh * * Marks a given nrrd axis as containing even-order spherical harmonics of * a given order. Based on axis size, determines if values are masked. * Returns 0 on success * 1 if given NULL pointer * 2 if nrrd has wrong type ( neither float nor double ) * 3 if axis doesn't exist * 4 if order is unsupported * 5 if axis has wrong size */ 67 int tijk_set_axis_esh( Nrrd *nrrd, unsigned int axis, unsigned int order ) { NrrdAxisInfo *axinfo = NULL; unsigned int masked = 0, lablen; if ( nrrd==NULL ) return 1; if ( nrrd->type!=nrrdTypeFloat && nrrd->type!=nrrdTypeDouble ) return 2; if ( axis>=nrrd->dim ) return 3; axinfo = nrrd->axis+axis; if ( order>tijk_max_esh_order ) return 4; if ( axinfo->size==tijk_esh_len[order/2]+1 ) masked = 1; else if ( axinfo->size!=tijk_esh_len[order/2] ) return 5; axinfo->label = ( char* ) airFree( axinfo->label ); lablen = strlen( "tijk_esh_" ) + ( masked?strlen( "mask_" ):0 ) + 3; axinfo->label = AIR_CALLOC( lablen, char ); sprintf( axinfo->label, "tijk_%sesh_%02u", masked?"mask_":"", order ); return 0; } /* tijk_set_axis_efs * * Marks a given nrrd axis as containing even-order fourier series of * a given order. Based on axis size, determines if values are masked. * Returns 0 on success * 1 if given NULL pointer * 2 if nrrd has wrong type ( neither float nor double ) * 3 if axis doesn't exist * 4 if order is unsupported * 5 if axis has wrong size */ 97 int tijk_set_axis_efs( Nrrd *nrrd, unsigned int axis, unsigned int order ) { NrrdAxisInfo *axinfo = NULL; unsigned int masked = 0, lablen; if ( nrrd==NULL ) return 1; if ( nrrd->type!=nrrdTypeFloat && nrrd->type!=nrrdTypeDouble ) return 2; if ( axis>=nrrd->dim ) return 3; axinfo = nrrd->axis+axis; if ( order>tijk_max_efs_order ) return 4; if ( axinfo->size==order+2 ) masked = 1; else if ( axinfo->size!=order+1 ) return 5; axinfo->label = ( char* ) airFree( axinfo->label ); lablen = strlen( "tijk_efs_" ) + ( masked?strlen( "mask_" ):0 ) + 3; axinfo->label = AIR_CALLOC( lablen, char ); sprintf( axinfo->label, "tijk_%sefs_%02u", masked?"mask_":"", order ); return 0; } /* tijk_get_axis_type * * Extracts Tijk information from a given nrrd axis and writes it to info. * Returns 0 on success * no "tijk_*" label counts as success -> tijk_class_unknown * 1 if given NULL pointer * 2 if nrrd has wrong type ( neither float nor double ) * 3 if axis doesn't exist * 4 if "tijk_*" label couldn't be parsed * 5 if label didn't fit axis size */ 127 int tijk_get_axis_type( tijk_axis_info *info, const Nrrd *nrrd, unsigned int axis ) { const tijk_type * tijk_types[] = { NULL, /* 0: tijk_2o2d_unsym */ NULL, /* 1: tijk_2o2d_sym */ NULL, /* 2: tijk_2o2d_asym */ NULL, /* 3: tijk_3o2d_sym */ NULL, /* 4: tijk_4o2d_unsym */ NULL, /* 5: tijk_4o2d_sym */ NULL, /* 6: tijk_1o3d */ NULL, /* 7: tijk_2o3d_unsym */ NULL, /* 8: tijk_2o3d_sym */ NULL, /* 9: tijk_2o3d_asym */ NULL, /* 10: tijk_3o3d_unsym */ NULL, /* 11: tijk_3o3d_sym */ NULL, /* 12: tijk_4o3d_sym */ NULL, /* 13: tijk_6o3d_sym */ NULL, /* 14: tijk_8o3d_sym */ NULL }; const NrrdAxisInfo *axinfo = NULL; const char *labelp = NULL; unsigned int i=0; if ( info==NULL || nrrd==NULL ) return 1; if ( nrrd->type!=nrrdTypeFloat && nrrd->type!=nrrdTypeDouble ) return 2; if ( axis>=nrrd->dim ) return 3; axinfo = nrrd->axis+axis; if ( axinfo->label==NULL || strncmp( axinfo->label, "tijk_", 5 ) ) { info->tclass = tijk_class_unknown; return 0; } labelp = axinfo->label+5; if ( !strncmp( labelp, "mask_", 5 ) ) { info->masked = 1; labelp += 5; } else info->masked = 0; if ( !strncmp( labelp, "esh_", 4 ) ) { info->tclass = tijk_class_esh; if ( 1!=sscanf( labelp+4, "%02u", &( info->order ) ) || info->order>tijk_max_esh_order || info->order%2!=0 ) return 4; if ( axinfo->size!=tijk_esh_len[info->order/2]+info->masked ) return 5; return 0; } if ( !strncmp( labelp, "efs_", 4 ) ) { info->tclass = tijk_class_efs; if ( 1!=sscanf( labelp+4, "%02u", &( info->order ) ) || info->order>tijk_max_efs_order || info->order%2!=0 ) return 4; if ( axinfo->size!=info->order+1+info->masked ) return 5; return 0; } tijk_types[ 0] = tijk_2o2d_unsym; tijk_types[ 1] = tijk_2o2d_sym; tijk_types[ 2] = tijk_2o2d_asym; tijk_types[ 3] = tijk_3o2d_sym; tijk_types[ 4] = tijk_4o2d_unsym; tijk_types[ 5] = tijk_4o2d_sym; tijk_types[ 6] = tijk_1o3d; tijk_types[ 7] = tijk_2o3d_unsym; tijk_types[ 8] = tijk_2o3d_sym; tijk_types[ 9] = tijk_2o3d_asym; tijk_types[10] = tijk_3o3d_unsym; tijk_types[11] = tijk_3o3d_sym; tijk_types[12] = tijk_4o3d_sym; tijk_types[13] = tijk_6o3d_sym; tijk_types[14] = tijk_8o3d_sym; while ( tijk_types[i]!=NULL ) { if ( !strcmp( labelp, tijk_types[i]->name ) ) { info->tclass = tijk_class_tensor; info->type = tijk_types[i]; if ( axinfo->size!=tijk_types[i]->num+info->masked ) return 5; return 0; } i++; } return 4; }