NAME

       fp2hdf - convert floating point data to HDF

SYNOPSIS

       fp2hdf -h[elp] fp2hdf infile [infile...]  -o[utfile outfile] [-r[aster] [ras_options...]]  [-f[loat]]

DESCRIPTION

       fp2hdf 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.

       Input  file(s) contain a single two-dimensional or three-dimensional floating point array in either ASCII
       text, native floating point, 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, see "Notes" below on how it must be organized.

OPTIONS

       -h[elp]
              Print a helpful summary of usage, and exit.

       -o[utfile] outfile
              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 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.

       -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)

INPUT

       If the input file format is ASCII text or native floating point, it must have the following input fields:

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

       Where:

       format Format designator ("TEXT", "FP32" or "FP64").

       nplanes
              Dimension of the depth axis ("1" for 2D input).

       nrows  Dimension of the vertical axis.

       ncols  Dimension of the horizontal axis.

       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.

EXAMPLE

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

               fp2hdf 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":

               fp2hdf 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":

               fp2hdf 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:

               fp2hdf 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:

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

SEE ALSO

       hdf(5)

                                                October 30, 1999                                       FP2HDF(1)