Provided by: hdf4-tools_4.2.14-1_amd64 bug

NAME

       hdfimport - imports ASCII or binary data into HDF

SYNOPSIS

       hdfimport <infile> [ [-t[ype] output-type | -n] [ <infile> [-t[ype] output-type | -n] ...
                 ] ] -o[utfile] outfile [-r[aster] [ras_opts ...]] [-f[loat]]

DESCRIPTION

       hdfimport converts floating point data to HDF  Scientific  Data  Set  (SDS)  and/or  8-bit
       Raster Image Set (RIS8) format, storing the results in an HDF file.  The image data can be
       scaled about a mean value.

OPTIONS

       infile(s)
              Name of the input file(s), containing a single two-dimensional or three-dimensional
              floating point array in either ASCII text, native floating point, native integer or
              HDF SDS format.  If an HDF file is used for input, it must contain an SDS.  The SDS
              need  only contain a dimension record and the data, but if it also contains maximum
              and minimum values and/or scales for each axis, these will be used.  If  the  input
              format  is ASCII text or native floating point or native integer, see "Notes" below
              on how it must be organized.

       -t[ype] output-type
              Optionally used for every input ASCII file to specify the data type of the data-set
              to  be  written.  If  not  specified  default  data  type is 32-bit floating point.
              output-type can be any of the following: FP32 (default), FP64, INT32, INT16,  INT8.
              It can be used only with ASCII files.

       -n     This  option  is  to be used only if the binary input file contains 64-bit floating
              point data and the default behaviour (default behaviour is to write it to a  32-bit
              floating  point  data-set)  should  be  overridden to write it to a 64-bit floating
              point data-set.

       -t[ype] output-type
              Data from one or more input files are stored as one or more data sets and/or images
              in one HDF output file, "outfile".

       -r[aster]
              Store output as a raster image set in the output file.

       -f[loat]
              Store  output  as a scientific data set in the output file.  This is the default if
              the "-r" option is not specified.

       [ras_opts ...]

              -e[xpand] horiz vert [depth]
                     Expand float data via pixel replication to produce  the  image(s).   "horiz"
                     and "vert" give the horizontal and vertical resolution of the image(s) to be
                     produced; and optionally, "depth" gives the number of images or depth planes
                     (for 3D input data).

              -i[nterp] horiz vert [depth]
                     Apply bilinear, or trilinear, interpolation to the float data to produce the
                     image(s).  "horiz", "vert", and "depth" must be greater than or equal to the
                     dimensions  of  the  original dataset.  If max and min are supplied in input
                     file, this option clips values that are greater than max or less  then  min,
                     setting them to the max and min, respectively.

              -p[alfile] palfile
                     Store the palette with the image.  Get the palette from "palfile"; which may
                     be an HDF file containing a palette, or a file containing a raw palette.

              -m[ean] mean
                     If a floating point mean value is given, the image will be scaled about  the
                     mean.  The new extremes (newmax and newmin), as given by:

                         newmax = mean + max(abs(max-mean), abs(mean-min))
                         newmin = mean - max(abs(max-mean), abs(mean-min))

                     will  be  equidistant  from the mean value.  If no mean value is given, then
                     the mean will be:

                         0.5 * (max + min)

       Notes: If the input file  format  is  ASCII  text  or  native  floating  point  or  native
              integer(32-bit, 16-bit, 8-bit), it must have the following input fields:

              format
              nplanes
              nrows
              cols
              max_value
              min_value
              [plane1 plane2 plane3 ...]
              row1 row2 row3 ...
              col1 col2 col3 ...
              data1 data2 data3 ...

              Where:

              format:
                     Format designator ("TEXT", "FP32", "FP64", "IN32", "IN16", "IN08").

              nplanes, nrows, ncols:
                     Dimensions  are  specified  in  the  order slowest changing dimension first.
                     ncols is dimension of the fastest changing dimension.  (horizontal  axis  or
                     X-axis in a 3D scale) nrows corresponds to dimension of the vertical axis or
                     Y-axis in a 3D scale.  nplanes corresponds to the slowest changing dimension
                     i.e.   dimension  of  the depth axis or the Z-axis in a 3D scale ("1" for 2D
                     input).

              max_value:
                     Maximum data value.

              min_value:
                     Minimum data value.

              plane1, plane2, plane3, ...:
                     Scales for depth axis.

              row1, row2, row3, ...:
                     Scales for the vertical axis.

              col1, col2, col3, ...:
                     Scales for the horizontal axis.

              data1, data2, data3, ...:
                     The data ordered by rows, left to right and top to bottom; then  optionally,
                     ordered by planes, front to back.

       For  FP32  and FP64 input format, "format", "nplanes", "nrows", "ncols", and "nplanes" are
       native  integers;  where  "format"  is  the  integer  representation  of  the  appropriate
       4-character string (0x46503332 for "FP32" and 0x46503634 for "FP64").  The remaining input
       fields are composed of native 32-bit floating point  values  for  FP32  input  format,  or
       native 64-bit floating point values for FP64 input format.

       For IN32, IN16 and IN08 input format, "format", "nplanes", "nrows", "ncols", and "nplanes"
       are native integers; where "format" is  the  integer  representation  of  the  appropriate
       4-character  string.   The  remaining  input  fields are composed of native 32-bit integer
       values for IN32 input format, or native 16-bit integer values for  IN16  input  format  or
       native 8-bit integer values for IN08 input format.

EXAMPLES

       Convert  floating point data in "f1.txt" to SDS format, and store it as an SDS in HDF file
       "o1":

       hdfimport f1.txt -o o1

       Convert floating point data in "f2.hdf" to 8-bit raster format, and store it as an RIS8 in
       HDF file "o2":

       hdfimport f2.hdf -o o2 -r

       Convert  floating  point data in "f3.bin" to 8-bit raster format and SDS format, and store
       both the RIS8 and the SDS in HDF file "o3":

       hdfimport f3.bin -o o3 -r -f

       Convert floating point data in "f4" to a 500x600 raster image, and store the RIS8  in  HDF
       file "o4".  Also store a palette from "palfile" with the image:

       hdfimport f4 -o o4 -r -e 500 600 -p palfile

       Convert  floating point data in "f5" to 200 planes of 500x600 raster images, and store the
       RIS8 in HDF file "o5".  Also scale the image data so that it  is  centered  about  a  mean
       value of 10.0:

       hdfimport f5 -o o5 -r -i 500 600 200 -m 10.0

                                           28 May 2016                               hdfimport(1)