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)