Man Linux: Main Page and Category List


       fp2hdf - convert floating point data to HDF


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


       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.


              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.

              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.


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


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

               [plane1 plane2 plane3 ...]
               row1 row2 row3 ...
               col1 col2 col3 ...
               data1 data2 data3 ...


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

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

       nrows  Dimension of the vertical axis.

       ncols  Dimension of the horizontal axis.

              Maximum data 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.


       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



                               October 30, 1999