Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	src/meet/meetNrrd.c	Lines:	238	252	94.4 %
Date:	2017-05-26	Branches:	223	274	81.4 %


/*
  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 "meet.h"

typedef union {
  const NrrdKernel ***k;
  void **v;
} _kernu;

/*
** ALLOCATES and returns a NULL-terminated array of all the
** NrrdKernels in Teem
*/
const NrrdKernel **
meetNrrdKernelAll(void) {
  airArray *arr;
  const NrrdKernel **kern;
  unsigned int ii;
  int di, ci, ai, dmax, cmax, amax;
  _kernu ku;

  ku.k = &kern;
  arr = airArrayNew(ku.v, NULL, sizeof(NrrdKernel *), 2);

  /* kernel.c */
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelZero;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBox;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBoxSupportDebug;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCatmullRomSupportDebug;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCatmullRomSupportDebugD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCatmullRomSupportDebugDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCos4SupportDebug;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCos4SupportDebugD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCos4SupportDebugDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCos4SupportDebugDDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCheap;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelHermiteScaleSpaceFlag;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelTent;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelForwDiff;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCentDiff;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBCCubic;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBCCubicD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBCCubicDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCatmullRom;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCatmullRomD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCatmullRomDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelAQuartic;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelAQuarticD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelAQuarticDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC3Quintic;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC3QuinticD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC3QuinticDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC4Hexic;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC4HexicD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC4HexicDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC4HexicDDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC4HexicApproxInverse;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC5Septic;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC5SepticD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC5SepticDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC5SepticDDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC5SepticApproxInverse;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelGaussian;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelGaussianD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelGaussianDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelDiscreteGaussian;

  /* winKernel.c */
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelHann;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelHannD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelHannDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBlackman;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBlackmanD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBlackmanDD;

  /* bsplKernel.c */
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline1;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline1D;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline2;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline2D;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline2DD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline3;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline3D;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline3DD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline3DDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline3ApproxInverse;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline4;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline4D;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline4DD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline4DDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline5;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline5D;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline5DD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline5DDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline5ApproxInverse;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline6;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline6D;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline6DD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline6DDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline7;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline7D;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline7DD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline7DDD;
  ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline7ApproxInverse;

  /* tmfKernel.c
   nrrdKernelTMF[D+1][C+1][A] is d<D>_c<C>_<A>ef:
   Dth-derivative, C-order continuous ("smooth"), A-order accurate
   (for D and C, index 0 accesses the function for -1)
    NRRD_EXPORT NrrdKernel *const nrrdKernelTMF[4][5][5];
  */
  dmax = AIR_CAST(int, nrrdKernelTMF_maxD);
  cmax = AIR_CAST(int, nrrdKernelTMF_maxC);
  amax = AIR_CAST(int, nrrdKernelTMF_maxA);
  for (di=-1; di<=dmax; di++) {
    for (ci=-1; ci<=cmax; ci++) {
      for (ai=1; ai<=amax; ai++) {
        ii = airArrayLenIncr(arr, 1);
        kern[ii] = nrrdKernelTMF[di+1][ci+1][ai];
      }
    }
  }

  /* NULL-terminate the list */
  ii = airArrayLenIncr(arr, 1); kern[ii] = NULL;
  /* nix, not nuke the airArray */
  airArrayNix(arr);
  return kern;
}

/* the knowledge here about what is a derivative of what is something
   that will be built into kernels in a future Teem version */
static const NrrdKernel *
kintegral(const NrrdKernel *kd) {
  const NrrdKernel *ret=NULL;

  /* the statement "INTGL(K)" is saying that K has a derivative with the
     usual name K##D.  This is made more convenient by the
     consistent use of the "D" suffix for indicating a derivative */
#define INTGL(K) if (K##D == kd) { ret = K; }
  INTGL(nrrdKernelHann);
  INTGL(nrrdKernelHannD);
  INTGL(nrrdKernelBlackman);
  INTGL(nrrdKernelBlackmanD);

  INTGL(nrrdKernelBSpline1);
  INTGL(nrrdKernelBSpline2);
  INTGL(nrrdKernelBSpline2D);
  INTGL(nrrdKernelBSpline3);
  INTGL(nrrdKernelBSpline3D);
  INTGL(nrrdKernelBSpline3DD);
  INTGL(nrrdKernelBSpline4);
  INTGL(nrrdKernelBSpline4D);
  INTGL(nrrdKernelBSpline4DD);
  INTGL(nrrdKernelBSpline5);
  INTGL(nrrdKernelBSpline5D);
  INTGL(nrrdKernelBSpline5DD);
  INTGL(nrrdKernelBSpline6);
  INTGL(nrrdKernelBSpline6D);
  INTGL(nrrdKernelBSpline6DD);
  INTGL(nrrdKernelBSpline7);
  INTGL(nrrdKernelBSpline7D);
  INTGL(nrrdKernelBSpline7DD);

  INTGL(nrrdKernelCos4SupportDebug);
  INTGL(nrrdKernelCos4SupportDebugD);
  INTGL(nrrdKernelCos4SupportDebugDD);
  INTGL(nrrdKernelCatmullRomSupportDebug);
  INTGL(nrrdKernelCatmullRomSupportDebugD);
  INTGL(nrrdKernelBCCubic);
  INTGL(nrrdKernelBCCubicD);
  INTGL(nrrdKernelCatmullRom);
  INTGL(nrrdKernelCatmullRomD);
  INTGL(nrrdKernelAQuartic);
  INTGL(nrrdKernelAQuarticD);
  INTGL(nrrdKernelC3Quintic);
  INTGL(nrrdKernelC3QuinticD);
  INTGL(nrrdKernelC4Hexic);
  INTGL(nrrdKernelC4HexicD);
  INTGL(nrrdKernelC4HexicDD);
  INTGL(nrrdKernelC5Septic);
  INTGL(nrrdKernelC5SepticD);
  INTGL(nrrdKernelC5SepticDD);
  INTGL(nrrdKernelGaussian);
  INTGL(nrrdKernelGaussianD);
#undef INTGL
  return ret;
}

/*
** Does more than call nrrdKernelCheck on all kernels:
** makes sure that all kernels have unique names
** makes sure that derivative relationships are correct
** Also, simply calling nrrdKernelCheck requires some knowledge
** of the kernel's needed parameters
**
** HEY: its problematic that because the various kernels have different
** parameter epsilon requirements, they usually end up having to be
** enumerated in some of the if/else statements below; it would be much
** better if new kernels didn't need to be so explicitly added!
*/
int
meetNrrdKernelAllCheck(void) {
  static const char me[]="meetNrrdKernelAllCheck";
  const NrrdKernel **kern, *kk, *ll;
  unsigned int ki, kj, pnum;
  airArray *mop;
  double epsl, XX, YY,
    parm0[NRRD_KERNEL_PARMS_NUM],
    parm1_1[NRRD_KERNEL_PARMS_NUM], parm1_X[NRRD_KERNEL_PARMS_NUM],
    parm[NRRD_KERNEL_PARMS_NUM];
  size_t evalNum;
  int EE;

  mop = airMopNew();
  kern = meetNrrdKernelAll();
  airMopAdd(mop, AIR_CAST(void*, kern), airFree, airMopAlways);
  evalNum = 120000; /* success of kernel integral test is surprisingly
                       dependent on this, likely due to the naive way
                       the integral is numerically computed; the current
                       value here represents some experimentation */
  epsl = 0.9e-5;
  XX = 7.0/3.0;  /* 2.333.. */
  YY = 43.0/9.0; /* 4.777.. */
  parm0[0] = AIR_NAN; /* shouldn't be read */
  parm1_1[0] = 1.0;
  parm1_X[0] = XX;
  ki = 0;
  while ((kk = kern[ki])) {
    kj = 0;
    while (kj < ki) {
      ll = kern[kj];
      if (kk == ll) {
        biffAddf(MEET, "%s: kern[%u] and [%u] were identical (%s)",
                 me, kj, ki, kk->name);
        airMopError(mop); return 1;
      }
      if (!airStrcmp(kk->name, ll->name)) {
        biffAddf(MEET, "%s: kern[%u] and [%u] have same name (%s)",
                 me, kj, ki, kk->name);
        airMopError(mop); return 1;
      }
      kj++;
    }
    pnum = kk->numParm;
    EE = 0;
    /* the second argument to CHECK is how much to scale up the
       permissible error in kernel evaluations (between float and double)
       The kernels for which this is higher should be targets for
       re-coding with an eye towards numerical accuracy */
#define CHECK(P, S, N)                                                  \
    if (!EE) EE |= nrrdKernelCheck(kk, (P), evalNum, epsl*(S),          \
                                   N, N,                                \
                                   kintegral(kk), (P));
    if (nrrdKernelBCCubic == kk ||
        nrrdKernelBCCubicD == kk ||
        nrrdKernelBCCubicDD == kk) {
      /* try a few settings of the 3 parms */
      ELL_3V_SET(parm, 1.0, 0.0, 0.0); CHECK(parm, 1, 2);
      ELL_3V_SET(parm, XX, 0.0, 0.0); CHECK(parm, 1, 2);
      ELL_3V_SET(parm, 1.0, 1.0/3.0, 1.0/3.0); CHECK(parm, 1, 2);
      ELL_3V_SET(parm, XX, 1.0/3.0, 1.0/3.0); CHECK(parm, 1, 2);
      ELL_3V_SET(parm, 1.0, 0.0, 1.0); CHECK(parm, 1, 2);
      ELL_3V_SET(parm, XX, 0.0, 1.0); CHECK(parm, 1, 2);
      ELL_3V_SET(parm, 1.0, 0.5, 0.0); CHECK(parm, 1, 2);
      ELL_3V_SET(parm, XX, 0.5, 0.0); CHECK(parm, 1, 2);
    } else if (2 == pnum) {
      if (nrrdKernelAQuartic == kk ||
          nrrdKernelAQuarticD == kk ||
          nrrdKernelAQuarticDD == kk) {
        ELL_2V_SET(parm, 1.0, 0.0); CHECK(parm, 10, 2);
        ELL_2V_SET(parm, 1.0, 0.5); CHECK(parm, 10, 2);
        ELL_2V_SET(parm, XX, 0.0);  CHECK(parm, 10, 2);
        ELL_2V_SET(parm, XX, 0.5);  CHECK(parm, 10, 2);
      } else if (nrrdKernelGaussian == kk ||
                 nrrdKernelGaussianD == kk ||
                 nrrdKernelGaussianDD == kk) {
        ELL_2V_SET(parm, 0.1, XX); CHECK(parm, 10, 2);
        ELL_2V_SET(parm, 0.1, YY); CHECK(parm, 10, 2);
        ELL_2V_SET(parm, 1.0, XX); CHECK(parm, 10, 2);
        ELL_2V_SET(parm, 1.0, YY); CHECK(parm, 10, 2);
        ELL_2V_SET(parm, XX, XX);  CHECK(parm, 10, 2);
        ELL_2V_SET(parm, XX, YY);  CHECK(parm, 10, 2);
      } else if (nrrdKernelHann == kk ||
                 nrrdKernelHannD == kk ||
                 nrrdKernelBlackman == kk) {
        ELL_2V_SET(parm, 0.5, XX); CHECK(parm, 100, 2);
        ELL_2V_SET(parm, 0.5, YY); CHECK(parm, 100, 2);
        ELL_2V_SET(parm, 1.0, XX); CHECK(parm, 100, 2);
        ELL_2V_SET(parm, 1.0, YY); CHECK(parm, 100, 2);
        ELL_2V_SET(parm, XX, XX);  CHECK(parm, 100, 2);
        ELL_2V_SET(parm, XX, YY);  CHECK(parm, 100, 2);
      } else if (nrrdKernelHannDD == kk ||
                 nrrdKernelBlackmanD == kk ||
                 nrrdKernelBlackmanDD == kk) {
        /* there are apparently bugs in these kernels */
        ELL_2V_SET(parm, 0.5, XX); CHECK(parm, 10000000, 2);
        ELL_2V_SET(parm, 0.5, YY); CHECK(parm, 10000000, 2);
        ELL_2V_SET(parm, 1.0, XX); CHECK(parm, 1000000, 2);
        ELL_2V_SET(parm, 1.0, YY); CHECK(parm, 1000000, 2);
        ELL_2V_SET(parm, XX, XX);  CHECK(parm, 100000, 2);
        ELL_2V_SET(parm, XX, YY);  CHECK(parm, 100000, 2);
      } else if (nrrdKernelDiscreteGaussian == kk) {
        ELL_2V_SET(parm, 0.1, XX); CHECK(parm, 1, 2);
        ELL_2V_SET(parm, 0.1, YY); CHECK(parm, 1, 2);
        ELL_2V_SET(parm, 1.0, XX); CHECK(parm, 1, 2);
        ELL_2V_SET(parm, 1.0, YY); CHECK(parm, 1, 2);
        ELL_2V_SET(parm, XX, XX);  CHECK(parm, 1, 2);
        ELL_2V_SET(parm, XX, YY);  CHECK(parm, 1, 2);
      } else {
        biffAddf(MEET, "%s: sorry, got unexpected 2-parm kernel %s",
                 me, kk->name);
        airMopError(mop); return 1;
      }
    } else if (1 == pnum) {
      if (strstr(kk->name, "TMF")) {
        /* these take a single parm, but its not support */
        parm[0] = 0.0;     CHECK(parm, 10, 2);
        parm[0] = 1.0/3.0; CHECK(parm, 10, 2);
      } else {
        /* zero, box, boxsup, cos4sup{,D,DD,DDD}, cheap,
           ctmrsup{,D,DD}, tent, fordif, cendif */
        /* takes a single support/scale parm[0], try two different values */
        if (nrrdKernelCos4SupportDebug == kk ||
            nrrdKernelCos4SupportDebugD == kk ||
            nrrdKernelCos4SupportDebugDD == kk ||
            nrrdKernelCos4SupportDebugDDD == kk ||
            nrrdKernelCatmullRomSupportDebugD == kk ||
            nrrdKernelCatmullRomSupportDebugDD == kk) {
          CHECK(parm1_1, 10, 4);
          CHECK(parm1_X, 10, 4);
        } else {
          CHECK(parm1_1, 1, 2);
          CHECK(parm1_X, 1, 2);
        }
      }
    } else if (0 == pnum) {
      /* C3Quintic{,D,DD,DD}, C4Hexic{,D,DD,DDD}, C5Septic{,D},
         hermiteSS, catmull-rom{,D}, bspl{3,5,7}{,D,DD,DDD} */
      if (nrrdKernelC3Quintic == kk ||
          nrrdKernelC3QuinticD == kk ||
          nrrdKernelC3QuinticDD == kk ||
          nrrdKernelC4Hexic == kk ||
          nrrdKernelC4HexicD == kk ||
          nrrdKernelC4HexicDD == kk ||
          nrrdKernelC4HexicDDD == kk ||
          nrrdKernelC5Septic == kk ||
          nrrdKernelC5SepticD == kk ||
          nrrdKernelC5SepticDD == kk ||
          nrrdKernelC5SepticDDD == kk
          ) {
        CHECK(parm0, 1, 2);
        CHECK(parm0, 1, 2);
      } else if (nrrdKernelBSpline5DD == kk ||
                 nrrdKernelBSpline5DDD == kk ||
                 nrrdKernelBSpline7DD == kk ) {
        CHECK(parm0, 100, 2);
      } else {
        CHECK(parm0, 10, 2);
      }
    } else {
      biffAddf(MEET, "%s: sorry, didn't expect %u parms for %s",
               me, pnum, kk->name);
      airMopError(mop); return 1;
    }
#undef CHECK
    if (EE) {
      biffMovef(MEET, NRRD, "%s: problem with kern[%u] \"%s\"", me, ki,
                kk->name ? kk->name : "(NULL name)");
      airMopError(mop); return 1;
    }
    ki++;
  }

  airMopOkay(mop);
  return 0;
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/*
2			Teem: Tools to process and visualize scientific data and images .
3			Copyright (C) 2013, 2012, 2011, 2010, 2009 University of Chicago
4			Copyright (C) 2008, 2007, 2006, 2005 Gordon Kindlmann
5			Copyright (C) 2004, 2003, 2002, 2001, 2000, 1999, 1998 University of Utah
6
7			This library is free software; you can redistribute it and/or
8			modify it under the terms of the GNU Lesser General Public License
9			(LGPL) as published by the Free Software Foundation; either
10			version 2.1 of the License, or (at your option) any later version.
11			The terms of redistributing and/or modifying this software also
12			include exceptions to the LGPL that facilitate static linking.
13
14			This library is distributed in the hope that it will be useful,
15			but WITHOUT ANY WARRANTY; without even the implied warranty of
16			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17			Lesser General Public License for more details.
18
19			You should have received a copy of the GNU Lesser General Public License
20			along with this library; if not, write to Free Software Foundation, Inc.,
21			51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22			*/
23
24			#include "meet.h"
25
26			typedef union {
27			const NrrdKernel ***k;
28			void **v;
29			} _kernu;
30
31			/*
32			** ALLOCATES and returns a NULL-terminated array of all the
33			** NrrdKernels in Teem
34			*/
35			const NrrdKernel **
36			meetNrrdKernelAll(void) {
37			airArray *arr;
38		2	const NrrdKernel **kern;
39			unsigned int ii;
40			int di, ci, ai, dmax, cmax, amax;
41			_kernu ku;
42
43			ku.k = &kern;
44		1	arr = airArrayNew(ku.v, NULL, sizeof(NrrdKernel *), 2);
45
46			/* kernel.c */
47		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelZero;
48		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBox;
49		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBoxSupportDebug;
50		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCatmullRomSupportDebug;
51		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCatmullRomSupportDebugD;
52		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCatmullRomSupportDebugDD;
53		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCos4SupportDebug;
54		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCos4SupportDebugD;
55		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCos4SupportDebugDD;
56		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCos4SupportDebugDDD;
57		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCheap;
58		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelHermiteScaleSpaceFlag;
59		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelTent;
60		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelForwDiff;
61		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCentDiff;
62		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBCCubic;
63		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBCCubicD;
64		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBCCubicDD;
65		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCatmullRom;
66		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCatmullRomD;
67		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelCatmullRomDD;
68		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelAQuartic;
69		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelAQuarticD;
70		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelAQuarticDD;
71		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC3Quintic;
72		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC3QuinticD;
73		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC3QuinticDD;
74		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC4Hexic;
75		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC4HexicD;
76		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC4HexicDD;
77		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC4HexicDDD;
78		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC4HexicApproxInverse;
79		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC5Septic;
80		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC5SepticD;
81		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC5SepticDD;
82		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC5SepticDDD;
83		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelC5SepticApproxInverse;
84		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelGaussian;
85		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelGaussianD;
86		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelGaussianDD;
87		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelDiscreteGaussian;
88
89			/* winKernel.c */
90		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelHann;
91		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelHannD;
92		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelHannDD;
93		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBlackman;
94		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBlackmanD;
95		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBlackmanDD;
96
97			/* bsplKernel.c */
98		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline1;
99		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline1D;
100		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline2;
101		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline2D;
102		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline2DD;
103		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline3;
104		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline3D;
105		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline3DD;
106		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline3DDD;
107		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline3ApproxInverse;
108		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline4;
109		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline4D;
110		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline4DD;
111		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline4DDD;
112		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline5;
113		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline5D;
114		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline5DD;
115		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline5DDD;
116		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline5ApproxInverse;
117		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline6;
118		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline6D;
119		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline6DD;
120		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline6DDD;
121		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline7;
122		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline7D;
123		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline7DD;
124		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline7DDD;
125		1	ii = airArrayLenIncr(arr, 1); kern[ii] = nrrdKernelBSpline7ApproxInverse;
126
127			/* tmfKernel.c
128			nrrdKernelTMF[D+1][C+1][A] is d<D>_c<C>_<A>ef:
129			Dth-derivative, C-order continuous ("smooth"), A-order accurate
130			(for D and C, index 0 accesses the function for -1)
131			NRRD_EXPORT NrrdKernel *const nrrdKernelTMF[4][5][5];
132			*/
133		1	dmax = AIR_CAST(int, nrrdKernelTMF_maxD);
134		1	cmax = AIR_CAST(int, nrrdKernelTMF_maxC);
135		1	amax = AIR_CAST(int, nrrdKernelTMF_maxA);
136	✓✓	10	for (di=-1; di<=dmax; di++) {
137	✓✓	48	for (ci=-1; ci<=cmax; ci++) {
138	✓✓	200	for (ai=1; ai<=amax; ai++) {
139		80	ii = airArrayLenIncr(arr, 1);
140		80	kern[ii] = nrrdKernelTMF[di+1][ci+1][ai];
141			}
142			}
143			}
144
145			/* NULL-terminate the list */
146		1	ii = airArrayLenIncr(arr, 1); kern[ii] = NULL;
147			/* nix, not nuke the airArray */
148		1	airArrayNix(arr);
149		2	return kern;
150		1	}
151
152			/* the knowledge here about what is a derivative of what is something
153			that will be built into kernels in a future Teem version */
154			static const NrrdKernel *
155			kintegral(const NrrdKernel *kd) {
156			const NrrdKernel *ret=NULL;
157
158			/* the statement "INTGL(K)" is saying that K has a derivative with the
159			usual name K##D. This is made more convenient by the
160			consistent use of the "D" suffix for indicating a derivative */
161			#define INTGL(K) if (K##D == kd) { ret = K; }
162	✓✓	686	INTGL(nrrdKernelHann);
163	✓✓	346	INTGL(nrrdKernelHannD);
164	✓✓	346	INTGL(nrrdKernelBlackman);
165	✓✓	346	INTGL(nrrdKernelBlackmanD);
166
167	✓✓	341	INTGL(nrrdKernelBSpline1);
168	✓✓	341	INTGL(nrrdKernelBSpline2);
169	✓✓	341	INTGL(nrrdKernelBSpline2D);
170	✓✓	341	INTGL(nrrdKernelBSpline3);
171	✓✓	341	INTGL(nrrdKernelBSpline3D);
172	✓✓	341	INTGL(nrrdKernelBSpline3DD);
173	✓✓	341	INTGL(nrrdKernelBSpline4);
174	✓✓	341	INTGL(nrrdKernelBSpline4D);
175	✓✓	341	INTGL(nrrdKernelBSpline4DD);
176	✓✓	341	INTGL(nrrdKernelBSpline5);
177	✓✓	341	INTGL(nrrdKernelBSpline5D);
178	✓✓	341	INTGL(nrrdKernelBSpline5DD);
179	✓✓	341	INTGL(nrrdKernelBSpline6);
180	✓✓	341	INTGL(nrrdKernelBSpline6D);
181	✓✓	341	INTGL(nrrdKernelBSpline6DD);
182	✓✓	341	INTGL(nrrdKernelBSpline7);
183	✓✓	341	INTGL(nrrdKernelBSpline7D);
184	✓✓	341	INTGL(nrrdKernelBSpline7DD);
185
186	✓✓	342	INTGL(nrrdKernelCos4SupportDebug);
187	✓✓	342	INTGL(nrrdKernelCos4SupportDebugD);
188	✓✓	342	INTGL(nrrdKernelCos4SupportDebugDD);
189	✓✓	342	INTGL(nrrdKernelCatmullRomSupportDebug);
190	✓✓	342	INTGL(nrrdKernelCatmullRomSupportDebugD);
191	✓✓	348	INTGL(nrrdKernelBCCubic);
192	✓✓	348	INTGL(nrrdKernelBCCubicD);
193	✓✓	341	INTGL(nrrdKernelCatmullRom);
194	✓✓	341	INTGL(nrrdKernelCatmullRomD);
195	✓✓	344	INTGL(nrrdKernelAQuartic);
196	✓✓	344	INTGL(nrrdKernelAQuarticD);
197	✓✓	342	INTGL(nrrdKernelC3Quintic);
198	✓✓	342	INTGL(nrrdKernelC3QuinticD);
199	✓✓	342	INTGL(nrrdKernelC4Hexic);
200	✓✓	342	INTGL(nrrdKernelC4HexicD);
201	✓✓	342	INTGL(nrrdKernelC4HexicDD);
202	✓✓	342	INTGL(nrrdKernelC5Septic);
203	✓✓	342	INTGL(nrrdKernelC5SepticD);
204	✓✓	342	INTGL(nrrdKernelC5SepticDD);
205	✓✓	346	INTGL(nrrdKernelGaussian);
206	✓✓	346	INTGL(nrrdKernelGaussianD);
207			#undef INTGL
208		340	return ret;
209			}
210
211			/*
212			** Does more than call nrrdKernelCheck on all kernels:
213			** makes sure that all kernels have unique names
214			** makes sure that derivative relationships are correct
215			** Also, simply calling nrrdKernelCheck requires some knowledge
216			** of the kernel's needed parameters
217			**
218			** HEY: its problematic that because the various kernels have different
219			** parameter epsilon requirements, they usually end up having to be
220			** enumerated in some of the if/else statements below; it would be much
221			** better if new kernels didn't need to be so explicitly added!
222			*/
223			int
224			meetNrrdKernelAllCheck(void) {
225			static const char me[]="meetNrrdKernelAllCheck";
226			const NrrdKernel *kern, kk, *ll;
227			unsigned int ki, kj, pnum;
228			airArray *mop;
229		2	double epsl, XX, YY,
230			parm0[NRRD_KERNEL_PARMS_NUM],
231			parm1_1[NRRD_KERNEL_PARMS_NUM], parm1_X[NRRD_KERNEL_PARMS_NUM],
232			parm[NRRD_KERNEL_PARMS_NUM];
233			size_t evalNum;
234			int EE;
235
236		1	mop = airMopNew();
237		1	kern = meetNrrdKernelAll();
238		1	airMopAdd(mop, AIR_CAST(void*, kern), airFree, airMopAlways);
239			evalNum = 120000; /* success of kernel integral test is surprisingly
240			dependent on this, likely due to the naive way
241			the integral is numerically computed; the current
242			value here represents some experimentation */
243			epsl = 0.9e-5;
244			XX = 7.0/3.0; /* 2.333.. */
245			YY = 43.0/9.0; /* 4.777.. */
246		1	parm0[0] = AIR_NAN; /* shouldn't be read */
247		1	parm1_1[0] = 1.0;
248		1	parm1_X[0] = XX;
249			ki = 0;
250	✓✓	312	while ((kk = kern[ki])) {
251			kj = 0;
252	✓✓	24180	while (kj < ki) {
253		11935	ll = kern[kj];
254	✗✓	11935	if (kk == ll) {
255			biffAddf(MEET, "%s: kern[%u] and [%u] were identical (%s)",
256			me, kj, ki, kk->name);
257			airMopError(mop); return 1;
258			}
259	✗✓	11935	if (!airStrcmp(kk->name, ll->name)) {
260			biffAddf(MEET, "%s: kern[%u] and [%u] have same name (%s)",
261			me, kj, ki, kk->name);
262			airMopError(mop); return 1;
263			}
264		11935	kj++;
265			}
266		155	pnum = kk->numParm;
267			EE = 0;
268			/* the second argument to CHECK is how much to scale up the
269			permissible error in kernel evaluations (between float and double)
270			The kernels for which this is higher should be targets for
271			re-coding with an eye towards numerical accuracy */
272			#define CHECK(P, S, N) \
273			if (!EE) EE \|= nrrdKernelCheck(kk, (P), evalNum, epsl*(S), \
274			N, N, \
275			kintegral(kk), (P));
276	✓✓✓✓	308	if (nrrdKernelBCCubic == kk \|\|
277	✓✓	154	nrrdKernelBCCubicD == kk \|\|
278		153	nrrdKernelBCCubicDD == kk) {
279			/* try a few settings of the 3 parms */
280	✓✗	6	ELL_3V_SET(parm, 1.0, 0.0, 0.0); CHECK(parm, 1, 2);
281	✓✗	6	ELL_3V_SET(parm, XX, 0.0, 0.0); CHECK(parm, 1, 2);
282	✓✗	6	ELL_3V_SET(parm, 1.0, 1.0/3.0, 1.0/3.0); CHECK(parm, 1, 2);
283	✓✗	6	ELL_3V_SET(parm, XX, 1.0/3.0, 1.0/3.0); CHECK(parm, 1, 2);
284	✓✗	6	ELL_3V_SET(parm, 1.0, 0.0, 1.0); CHECK(parm, 1, 2);
285	✓✗	6	ELL_3V_SET(parm, XX, 0.0, 1.0); CHECK(parm, 1, 2);
286	✓✗	6	ELL_3V_SET(parm, 1.0, 0.5, 0.0); CHECK(parm, 1, 2);
287	✓✗	6	ELL_3V_SET(parm, XX, 0.5, 0.0); CHECK(parm, 1, 2);
288	✓✓	152	} else if (2 == pnum) {
289	✓✓✓✓	24	if (nrrdKernelAQuartic == kk \|\|
290	✓✓	12	nrrdKernelAQuarticD == kk \|\|
291		11	nrrdKernelAQuarticDD == kk) {
292	✓✗	6	ELL_2V_SET(parm, 1.0, 0.0); CHECK(parm, 10, 2);
293	✓✗	6	ELL_2V_SET(parm, 1.0, 0.5); CHECK(parm, 10, 2);
294	✓✗	6	ELL_2V_SET(parm, XX, 0.0); CHECK(parm, 10, 2);
295	✓✗	6	ELL_2V_SET(parm, XX, 0.5); CHECK(parm, 10, 2);
296	✓✓✓✓	18	} else if (nrrdKernelGaussian == kk \|\|
297	✓✓	9	nrrdKernelGaussianD == kk \|\|
298		8	nrrdKernelGaussianDD == kk) {
299	✓✗	6	ELL_2V_SET(parm, 0.1, XX); CHECK(parm, 10, 2);
300	✓✗	6	ELL_2V_SET(parm, 0.1, YY); CHECK(parm, 10, 2);
301	✓✗	6	ELL_2V_SET(parm, 1.0, XX); CHECK(parm, 10, 2);
302	✓✗	6	ELL_2V_SET(parm, 1.0, YY); CHECK(parm, 10, 2);
303	✓✗	6	ELL_2V_SET(parm, XX, XX); CHECK(parm, 10, 2);
304	✓✗	6	ELL_2V_SET(parm, XX, YY); CHECK(parm, 10, 2);
305	✓✓✓✓	12	} else if (nrrdKernelHann == kk \|\|
306	✓✓	6	nrrdKernelHannD == kk \|\|
307		5	nrrdKernelBlackman == kk) {
308	✓✗	6	ELL_2V_SET(parm, 0.5, XX); CHECK(parm, 100, 2);
309	✓✗	6	ELL_2V_SET(parm, 0.5, YY); CHECK(parm, 100, 2);
310	✓✗	6	ELL_2V_SET(parm, 1.0, XX); CHECK(parm, 100, 2);
311	✓✗	6	ELL_2V_SET(parm, 1.0, YY); CHECK(parm, 100, 2);
312	✓✗	6	ELL_2V_SET(parm, XX, XX); CHECK(parm, 100, 2);
313	✓✗	6	ELL_2V_SET(parm, XX, YY); CHECK(parm, 100, 2);
314	✓✓✓✓	6	} else if (nrrdKernelHannDD == kk \|\|
315	✓✓	3	nrrdKernelBlackmanD == kk \|\|
316		2	nrrdKernelBlackmanDD == kk) {
317			/* there are apparently bugs in these kernels */
318	✓✗	6	ELL_2V_SET(parm, 0.5, XX); CHECK(parm, 10000000, 2);
319	✓✗	6	ELL_2V_SET(parm, 0.5, YY); CHECK(parm, 10000000, 2);
320	✓✗	6	ELL_2V_SET(parm, 1.0, XX); CHECK(parm, 1000000, 2);
321	✓✗	6	ELL_2V_SET(parm, 1.0, YY); CHECK(parm, 1000000, 2);
322	✓✗	6	ELL_2V_SET(parm, XX, XX); CHECK(parm, 100000, 2);
323	✓✗	6	ELL_2V_SET(parm, XX, YY); CHECK(parm, 100000, 2);
324	✓✗	1	} else if (nrrdKernelDiscreteGaussian == kk) {
325	✓✗	2	ELL_2V_SET(parm, 0.1, XX); CHECK(parm, 1, 2);
326	✓✗	2	ELL_2V_SET(parm, 0.1, YY); CHECK(parm, 1, 2);
327	✓✗	2	ELL_2V_SET(parm, 1.0, XX); CHECK(parm, 1, 2);
328	✓✗	2	ELL_2V_SET(parm, 1.0, YY); CHECK(parm, 1, 2);
329	✓✗	2	ELL_2V_SET(parm, XX, XX); CHECK(parm, 1, 2);
330	✓✗	2	ELL_2V_SET(parm, XX, YY); CHECK(parm, 1, 2);
331			} else {
332			biffAddf(MEET, "%s: sorry, got unexpected 2-parm kernel %s",
333			me, kk->name);
334			airMopError(mop); return 1;
335			}
336	✓✓	139	} else if (1 == pnum) {
337	✓✓	94	if (strstr(kk->name, "TMF")) {
338			/* these take a single parm, but its not support */
339	✓✗	160	parm[0] = 0.0; CHECK(parm, 10, 2);
340	✓✗	160	parm[0] = 1.0/3.0; CHECK(parm, 10, 2);
341			} else {
342			/* zero, box, boxsup, cos4sup{,D,DD,DDD}, cheap,
343			ctmrsup{,D,DD}, tent, fordif, cendif */
344			/* takes a single support/scale parm[0], try two different values */
345	✓✓✓✓	23	if (nrrdKernelCos4SupportDebug == kk \|\|
346	✓✓	13	nrrdKernelCos4SupportDebugD == kk \|\|
347	✓✓	12	nrrdKernelCos4SupportDebugDD == kk \|\|
348	✓✓	11	nrrdKernelCos4SupportDebugDDD == kk \|\|
349	✓✓	10	nrrdKernelCatmullRomSupportDebugD == kk \|\|
350		9	nrrdKernelCatmullRomSupportDebugDD == kk) {
351	✓✗	12	CHECK(parm1_1, 10, 4);
352	✓✗	12	CHECK(parm1_X, 10, 4);
353			} else {
354	✓✗	16	CHECK(parm1_1, 1, 2);
355	✓✗	16	CHECK(parm1_X, 1, 2);
356			}
357			}
358	✓✗	45	} else if (0 == pnum) {
359			/* C3Quintic{,D,DD,DD}, C4Hexic{,D,DD,DDD}, C5Septic{,D},
360			hermiteSS, catmull-rom{,D}, bspl{3,5,7}{,D,DD,DDD} */
361	✓✓✓✓	80	if (nrrdKernelC3Quintic == kk \|\|
362	✓✓	44	nrrdKernelC3QuinticD == kk \|\|
363	✓✓	43	nrrdKernelC3QuinticDD == kk \|\|
364	✓✓	42	nrrdKernelC4Hexic == kk \|\|
365	✓✓	41	nrrdKernelC4HexicD == kk \|\|
366	✓✓	40	nrrdKernelC4HexicDD == kk \|\|
367	✓✓	39	nrrdKernelC4HexicDDD == kk \|\|
368	✓✓	38	nrrdKernelC5Septic == kk \|\|
369	✓✓	37	nrrdKernelC5SepticD == kk \|\|
370	✓✓	36	nrrdKernelC5SepticDD == kk \|\|
371		35	nrrdKernelC5SepticDDD == kk
372			) {
373	✓✗	22	CHECK(parm0, 1, 2);
374	✓✗	22	CHECK(parm0, 1, 2);
375	✓✓✓✓	66	} else if (nrrdKernelBSpline5DD == kk \|\|
376	✓✓	33	nrrdKernelBSpline5DDD == kk \|\|
377		32	nrrdKernelBSpline7DD == kk ) {
378	✓✗	6	CHECK(parm0, 100, 2);
379			} else {
380	✓✗	62	CHECK(parm0, 10, 2);
381			}
382			} else {
383			biffAddf(MEET, "%s: sorry, didn't expect %u parms for %s",
384			me, pnum, kk->name);
385			airMopError(mop); return 1;
386			}
387			#undef CHECK
388	✗✓	155	if (EE) {
389			biffMovef(MEET, NRRD, "%s: problem with kern[%u] \"%s\"", me, ki,
390			kk->name ? kk->name : "(NULL name)");
391			airMopError(mop); return 1;
392			}
393		155	ki++;
394			}
395
396		1	airMopOkay(mop);
397		1	return 0;
398		1	}