/*

  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"

/*

******** nrrdSplice()

**

** (opposite of nrrdSlice): replaces one slice of a nrrd with

** another nrrd.  Will allocate memory for output only if nout != nin.

*/

int

nrrdSplice(Nrrd *nout, const Nrrd *nin, const Nrrd *nslice,

           unsigned int axis, size_t pos) {

  static const char me[]="nrrdSplice", func[]="splice";

  size_t

    I,

    rowLen,                  /* length of segment */

    colStep,                 /* distance between start of each segment */

    colLen;                  /* number of periods */

  unsigned int ai;

  char *src, *dest, *sliceCont;

  }

  }

  /* check that desired slice location is legit */

  }

  }

  /* check that slice will fit in nin */

  }

             "dim of input (%d)", me, nslice->dim, nin->dim);

  }

  }

    }

  }

    unsigned int foundExitCondition = 0;

    }

    }

    }

  }

  /* else we're going to splice in place */

  /* the following was copied from nrrdSlice() */

  /* set up control variables */

  rowLen = colLen = 1;

  }

  /* the skinny */

    /* HEY: replace with AIR_MEMCPY() or similar, when applicable */

  }

  }

  /* basic info copied by nrrdCopy above */

/*

******** nrrdInset()

**

** (opposite of nrrdCrop()) replace some sub-volume inside a nrrd with

** another given nrrd.

**

*/

int

nrrdInset(Nrrd *nout, const Nrrd *nin, const Nrrd *nsub, const size_t *min) {

  static const char me[]="nrrdInset", func[] = "inset";

  unsigned int ai;

    lineSize,                /* #bytes in one scanline to be copied */

    typeSize,                /* size of data type */

    cIn[NRRD_DIM_MAX],       /* coords for line start, in input */

    cOut[NRRD_DIM_MAX],      /* coords for line start, in output */

    szIn[NRRD_DIM_MAX],

    szOut[NRRD_DIM_MAX],

    idxIn, idxOut,           /* linear indices for input and output */

    numLines;                /* number of scanlines in output nrrd */

  /* errors */

  }

  }

  }

  }

             me, nin->dim, nsub->dim);

  }

  }

    }

  }

               "input indices [0,%s]", me, ai,

    }

  }

    }

  }

  /* else we're going to inset in place */

  /* WARNING: following code copied/modified from nrrdCrop(),

     so the meanings of "in"/"out", "src"/"dest" are all messed up */

  numLines = 1;

  }

  /* the skinny */

  }

    }

    /* the lowest coordinate in cOut[] will stay zero, since we are

       copying one (1-D) scanline at a time */

  }

  /* HEY: before Teem version 2.0 figure out nrrdKind stuff here */

            airSprintSize_t(stmp[0], min[ai]));

  }

  }

  /* basic info copied by nrrdCopy above */

}

#define MIRROR(N, I, M) \

  M = (I < 0 ? -I : I); \

  M = M % (2*N);        \

  M = (M >= N           \

       ? 2*N - 1 - M    \

       : M)             \

size_t

_nrrdMirror_64(size_t N, ptrdiff_t I) {

  size_t M;

       : M);

}

unsigned int

_nrrdMirror_32(unsigned int N, int I) {

  unsigned int M;

       : M);

}

/*

******** nrrdPad_va()

**

** strictly for padding

*/

int

nrrdPad_va(Nrrd *nout, const Nrrd *nin,

           const ptrdiff_t *min, const ptrdiff_t *max, int boundary, ...) {

  static const char me[]="nrrdPad_va", func[]="pad";

  int outside; /* whether current sample in output has any coordinates

                  that are outside the input volume (this is per-sample,

                  not per-axis) */

  unsigned int ai;

    cIn[NRRD_DIM_MAX];       /* coords for line start, in input */

    typeSize,

    idxIn, idxOut,           /* linear indices for input and output */

    numOut,                  /* number of elements in output nrrd */

    szIn[NRRD_DIM_MAX],

    szOut[NRRD_DIM_MAX],

    cOut[NRRD_DIM_MAX];      /* coords for line start, in output */

  char *dataIn, *dataOut;

  }

  }

  }

  }

  }

  case nrrdBoundaryPad:

  case nrrdBoundaryBleed:

  case nrrdBoundaryWrap:

  case nrrdBoundaryMirror:

    break;

  default:

  }

  /*

  printf("!%s: boundary = %d, padValue = %g\n", me, boundary, padValue);

  */

    }

    }

  }

  /* this shouldn't actually be necessary .. */

  }

  /* allocate */

  numOut = 1;

  }

  }

  /* the skinny */

  }

    outside = 0;

      case nrrdBoundaryPad: /* HEY, this shouldn't result in any

                               input coordinate being set */

      case nrrdBoundaryBleed:

          outside = 1;

        break;

      case nrrdBoundaryWrap:

          /* HEY: shouldn't have to cast szIn[ai] to ptrdiff_t */

          outside = 1;

        }

        break;

      case nrrdBoundaryMirror:

          outside = 1;

        }

        break;

      }

    }

      /* the cIn coords are within the input nrrd: do memcpy() of whole

         1-D scanline, then artificially bump for-loop to the end of

         the scanline */

             szIn[0]*typeSize);

      /* we copy only a single value */

      }

    }

  }

                                         NRRD_AXIS_INFO_MIN_BIT |

                                         NRRD_AXIS_INFO_MAX_BIT ))) {

  }

      /* nothing changed along this axis; the kind should be preserved */

    }

  }

            airSprintPtrdiff_t(stmp[0], min[ai]),

            airSprintPtrdiff_t(stmp[1], max[ai]));

  }

            padValue);

  }

  }

                        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

                           ? 0

                           : NRRD_BASIC_INFO_KEYVALUEPAIRS_BIT))) {

  }

  /* copy origin, then shift it along the spatial axes */

                            1.0, nout->spaceOrigin,

  }

/*

******** nrrdPad_nva()

**

** unlike other {X_va,X_nva} pairs, nrrdPad_nva() is a wrapper around

** nrrdPad_va() instead of the other way around.

*/

int

nrrdPad_nva(Nrrd *nout, const Nrrd *nin,

            const ptrdiff_t *min, const ptrdiff_t *max,

            int boundary, double padValue) {

  static const char me[]="nrrdPad_nva";

  int E;

  }

  }

  }

/*

******** nrrdSimplePad_va()

**

** pads by a given amount on top and bottom of EVERY axis

*/

int

nrrdSimplePad_va(Nrrd *nout, const Nrrd *nin, unsigned int pad,

                 int boundary, ...) {

  static const char me[]="nrrdSimplePad_va";

  unsigned ai;

  int ret;

  double padValue;

  }

  }

  }

  }

}

/*

******** nrrdSimplePad_nva()

**

** unlike other {X_va,X_nva} pairs, nrrdSimplePad_nva() is a wrapper

** around nrrdSimplePad_va() instead of the other way around.

*/

int

nrrdSimplePad_nva(Nrrd *nout, const Nrrd *nin, unsigned int pad,

                  int boundary, double padValue) {

  static const char me[]="nrrdSimplePad_nva";

  int E;

  }

  }

  }

}