/*

  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 "unrrdu.h"

#include "privateUnrrdu.h"

/* learned: some header file must declare private functions

** within extern "C" so that others can link with them

*/

#define NO_STRING "."

#define INFO "Create a nrrd (or nrrd header) from scratch"

static const char *_unrrdu_makeInfoL =

(INFO

 ".  The data can be in one or more files, or coming from stdin. "

 "This provides an easy way of specifying the information about some "

 "data as to wrap it in a NRRD file, either to pass on for further "

 "unu processing, or to save to disk.  Note that with \"-h\", this creates "

 "a detached nrrd header file, without ever reading or writing data files. "

 "\n \n "

 "When using multiple datafiles, the data from each is simply "

 "concatenated in memory (as opposed to interleaving along a faster axis). "

 "Keep in mind that all the options below refer to the finished data segment "

 "resulting from joining all the data pieces together, "

 "except for \"-ls\", \"-bs\", and \"-e\", which apply (uniformly) to the "

 "individual data files. Use the \"-fd\" option when the things being joined "

 "together are not slices of the final result, but slabs or scanlines. "

 "It may be easier to put multiple filenames in a response file; "

 "there can be one or more filenames per line of the response file. "

 "You can also use a sprintf-style format to identify a numbered "

 "range of files, so for example \"-i I.%03d 1 90 1\" "

 "refers to I.001, I.002, ... I.090, using the inclusive range from the first "

 "to the second integer (following the sprintf-style format), in steps of "

 "the third.  Can optionally give a fourth integer to serve same role as "

 "\"-fd\"."

 "\n \n "

 "NOTE: for the \"-l\" (labels), \"-u\" (units), and \"-spu\" (space units) "

 "options below, you can use a single unquoted period (.) to signify "

 "an empty string.  This creates a convenient way to convey something that "

 "the shell doesn't make it easy to convey.  Shell expansion weirdness "

 "also requires the use of quotes around the arguments to \"-orig\" (space "

 "origin), \"-dirs\" (space directions), and \"-mf\" (measurement frame).\n "

 "\n "

 "* Uses various components of file and data IO, but currently there is no "

 "library function that encapsulates the functionality here.");

int

unrrdu_makeMain(int argc, const char **argv, const char *me,

                hestParm *hparm) {

    **dataFileNames, **kvp, *content, encInfo[AIR_STRLEN_LARGE];

  Nrrd *nrrd;

    encodingType, gotSpacing, gotThickness, space,

    spaceSet;

    centeringsLen, unitsLen, labelLen, kvpLen, spunitsLen, dataFileDim,

    spaceDim;

  airArray *mop;

  NrrdIoState *nio;

  FILE *fileOut;

    *spcStr, *_origStr, *origStr, *_dirStr, *dirStr, *_mframeStr, *mframeStr;

  const NrrdEncoding *encoding;

  /* so that long lists of filenames can be read from file */

             "Generate header ONLY: don't write out the whole nrrd, "

             "don't even bother reading the input data, just output the "

             "detached nrrd header file (usually with a \".nhdr\" "

             "extension) determined by the options below. The single "

             "constraint is that detached headers are incompatible with "

             "using stdin as the data source.");

             &dataFileNames, "-",

             "Filename(s) of data file(s); use \"-\" for stdin. *OR*, can "

             "use sprintf-style format for identifying a range of numbered "

             "files, see above for details.", &nameLen);

             "type of data (e.g. \"uchar\", \"int\", \"float\", "

             "\"double\", etc.)",

             "number of samples along each axis (and implicit indicator "

             "of dimension of nrrd)", &sizeLen);

             &dataFileDim, "0",

             "When using *multiple* input data files (to \"-i\"), what is "

             "the dimension of the array data in each individual file. By "

             "default (not using this option), this dimension is assumed "

             "to be one less than the whole data dimension. ");

             &spacing, "nan",

             "spacing between samples on each axis.  Use \"nan\" for "

             "any non-spatial axes (e.g. spacing between red, green, and blue "

             "along axis 0 of interleaved RGB image data)", &spacingLen);

             &thickness, "nan",

             "thickness of region represented by one sample along each axis. "

             "  As with spacing, use \"nan\" for "

             "any non-spatial axes.", &thicknessLen);

             "what \"kind\" is each axis, from the nrrdKind airEnum "

             "(e.g. space, time, 3-vector, 3D-masked-symmetric-matrix, "

             "or \"none\" to signify no kind)", &kindsLen);

             &centerings, "",

             "kind of centering (node or cell) for each axis, or "

             "\"none\" to signify no centering", &centeringsLen);

             "short string labels for each of the axes", &labelLen);

             "short strings giving units for each of the axes", &unitsLen);

             "Specifies the content string of the nrrd, which is built upon "

             "by many nrrd function to record a history of operations");

             "number of ascii lines to skip before reading data");

             "number of bytes to skip (after skipping ascii lines, if any) "

             "before reading data.  Can use \"-bs -1\" to skip a binary "

             "header of unknown length in raw-encoded data");

         "encoding of input data. Possibilities include:"

         "\n \b\bo \"raw\": raw encoding"

         "\n \b\bo \"ascii\": ascii values, one scanline per line of text, "

         "values within line are delimited by space, tab, or comma"

         "\n \b\bo \"hex\": two hex digits per byte");

           "\n \b\bo \"gzip\", \"gz\": gzip compressed raw data");

           "\n \b\bo \"bzip2\", \"bz2\": bzip2 compressed raw data");

             &encodingType, "raw",

             "Endianness of data; relevent for any data with value "

             "representation bigger than 8 bits, with a non-ascii encoding: "

             "\"little\" for Intel and friends "

             "(least significant byte first, at lower address); "

             "\"big\" for everyone else (most significant byte first). "

             "Defaults to endianness of this machine",

             "key/value string pairs to be stored in nrrd.  Each key/value "

             "pair must be a single string (put it in \"\"s "

             "if the key or the value contain spaces).  The format of each "

             "pair is \"<key>:=<value>\", with no spaces before or after "

             "\":=\".", &kvpLen);

             "identify the space (e.g. \"RAS\", \"LPS\") in which the array "

             "conceptually lives, from the nrrdSpace airEnum, which in turn "

             "determines the dimension of the space.  Or, use an integer>0 to"

             "give the dimension of a space that nrrdSpace doesn't know about. "

             "By default (not using this option), the enclosing space is "

             "set as unknown.");

             "(NOTE: must quote vector) the origin in space of the array: "

             "the location of the center "

             "of the first sample, of the form \"(x,y,z)\" (or however "

             "many coefficients are needed for the chosen space). Quoting the "

             "vector is needed to stop interpretation from the shell");

             &_dirStr, "",

             "(NOTE: must quote whole vector list) The \"space directions\": "

             "the vectors in space spanned by incrementing (by one) each "

             "axis index (the column vectors of the index-to-world "

             "matrix transform), OR, \"none\" for non-spatial axes. Give "

             "one vector per axis. (Quoting around whole vector list, not "

             "individually, is needed because of limitations in the parser)");

             &_mframeStr, "",

             "(NOTE: must quote whole vector list). Each vector is a *column* "

             "vector of the matrix which transforms from coordinates in "

             "measurement frame (in which the coefficients of vectors and "

             "tensors are given) to coordinates of world space (given with "

             "\"-spc\"). This is not a per-axis field: the column vectors "

             "comprise a D-by-D square matrix, where D is the dimension of "

             "world space.");

             &spunits, "",

             "short strings giving units with which the coefficients of the "

             "space origin and direction vectors are measured.", &spunitsLen);

             "output filename.  If \"-h\" has been used, the output file is "

             "always a detached header.  Otherwise, use extension "

             "\".nrrd\" to signal creation of self-contained nrrd, and "

             "\".nhdr\" to signal creating of a detached header with "

             "(single) data file.");

             "when *not* using \"-h\" and saving to a \".nhdr\" file, using "

             "this option allows you to explicitly name the data file, "

             "instead of (by default, not using this option) having it be "

             "the same filename base as the header file.");

  /* ---------------- BEGIN ERROR CHECKING --------------- */

                "with stdin (\"-\") as data source "

      }

    }

  }

  /* given the information we have, we set the fields in the nrrdIoState

     so as to simulate having read the information from a header */

            "range [1,NRRD_DIM_MAX] = [1,%d]\n", me, sizeLen, NRRD_DIM_MAX);

  }

            "%s: number of spacings (%d) not same as dimension (%d)\n",

            me, spacingLen, sizeLen);

  }

            "%s: number of thicknesses (%d) not same as dimension (%d)\n",

            me, thicknessLen, sizeLen);

  }

            "%s: number of labels (%d) not same as dimension (%d)\n",

            me, labelLen, sizeLen);

  }

            "%s: number of units (%d) not same as dimension (%d)\n",

            me, unitsLen, sizeLen);

  }

            "%s: number of kinds (%d) not same as dimension (%d)\n",

            me, kindsLen, sizeLen);

  }

            "%s: number of centerings (%d) not same as dimension (%d)\n",

            me, centeringsLen, sizeLen);

  }

  /* ----------------- END ERROR CHECKING ---------------- */

  /* ----------------- BEGIN SETTING INFO ---------------- */

  /* have to simulate having parsed this line for error checking in

     _nrrdDataFNCheck() to not cause problems */

    /* trying to do a formatted filename list */

    }

    bufLen = 0;

    }

      }

    }

                                                nio, AIR_TRUE)) {

    }

    /* single or regular LIST of files */

    }

    }

  }

  }

  }

  }

      }

    }

  }

      }

    }

  }

  }

      /* a hack: have to use NrrdIoState->line as the channel to communicate

         the key/value pair, since we have to emulate it having been

         read from a NRRD header.  But because nio doesn't own the

         memory, we must be careful to unset the pointer prior to

         NrrdIoStateNix being called by the mop. */

                                                 nio, AIR_TRUE)) {

      }

    }

  }

    /* have to allocate line then pass it to parsing */

    bufLen = 0;

    }

      }

    }

                                            nio, AIR_TRUE)) {

    }

  }

    /* have to allocate line then pass it to parsing */

    bufLen = 0;

    }

      }

    }

                                              nio, AIR_TRUE)) {

    }

  }

      /* couldn't parse it as space, perhaps its a uint */

      }

      /* else we did parse it as a uint */

      /* we did parse a known space */

    }

    spaceSet = AIR_TRUE;

    /* we got no space information at all */

    spaceSet = AIR_FALSE;

  }

    /* why this is necessary is a bit confusing to me, both the check for

       enclosing quotes, and the need to use to a separate variable (isn't

       hest doing memory management of addresses, not variables?) */

    }

    /* same hack about using NrrdIoState->line as basis for parsing */

                                                   nio, AIR_TRUE)) {

    }

  }

    /* same confusion as above */

    }

    /* same hack about using NrrdIoState->line as basis for parsing */

                                                       nio, AIR_TRUE)) {

    }

  }

    /* same confusion as above */

    }

    /* same hack about using NrrdIoState->line as basis for parsing */

                                                        nio, AIR_TRUE)) {

    }

  }

    }

              "%s: number of space units (%d) "

              "not same as space dimension (%d)\n",

              me, spunitsLen, nrrd->spaceDim);

    }

      }

    }

    /* have to allocate line then pass it to parsing */

    bufLen = 0;

    }

      }

    }

                                                  nio, AIR_TRUE)) {

    }

  }

  }

  /* ----------------- END SETTING INFO ---------------- */

  /* -------------------- BEGIN I/O -------------------- */

  /* for the sake of reading in data files, this is as good a guess

     as any as to what the header-relative path to them is.  This

     assuages concerns that come up even with headerOnly */

    /* we open and hand off the output FILE* to the nrrd writer, which

       will not write any data, because of nio->skipData = AIR_TRUE */

    }

    /* whatever line and byte skipping is required will be simply

       recorded in the header, and done by the next reader */

    }

  } else {

    /* all this does is read the data from the files.  We up the verbosity

       because of all places this is probably where we really want it */

    }

    /* then save normally */

    }

  }

UNRRDU_CMD(make, INFO);