Fortran-90 MODULE MODGISIO


I/O API 4.0 only!!

Contents

Introductin
Supported GIS File Types
SETSWAP(), BINVERBOSE(), BINTERSE()
RDGFHDR()
BILHDR()
WRGFHDR()
RDAFILE()
WRAFILE()
RDARC()
WRARC()
RDBRFILE(), RDZBRFILE()
WRBRFILE(), WRZBRFILE()
RDBIFILE(), RDZBIFILE()
RDBI2FILE(), RDZBI2FILE()
RDBI4FILE(), RDZBI4FILE()
WRBIFILE(), WRZBIFILE()
WRBI2FILE(), WRZBI2FILE()
WRBI4FILE(), WRZBI4FILE()
Worker-routines from gisio.c

Introduction

New Apr 2025 for I/O API 4.0 only!!

Routines for reading and writing various GIS-format files: ARC and ASC ASCII formatted, and GRIDFLOAT and BIL1 (uint8_t), BIL2 (uint16_t), and BIL4 (uint32_t) binary GIS-style files, with on-the-fly transpose from GIS scan line row-order to normal-model bottom-to-top row-order, referencing the files by logical name.

All the binary (BIL and FLT) routines have variants that do gzip compatible compression or de-compression on the fly, using libz. (It has been shown that for most meteorology/environmental data, the combination of libz overhead plus the reduced I/O time from reading or writing the compressed data is faster than just reading or writing the matching un-compressed data (which can be important in time-constrained applications like real-time forecasting).)

Path-names for the binary-type external header files are the result of appending .hdr onto the path name for the corresponding data file, e.g., the header for /foo/bar/qux.dat would be /foo/bar/qux.dat.hdr

Back to Contents

Supported GIS File Types

For more about these file types, see the GDAL documentation about "raster" (gridded) file formats; for more about GIS data format translation see gdal_translate.

The I/O API MODULE MODGISIO does not support all of these formats: it supports the following subset (extended by on-the-fly gzip compression).
Note that all of these use "scan-line" (top-to-bottom, left-to-right) array-storage order.

BIL
one-byte (8 bit) INTEGER direct-access binary

BIL2
two-byte (16 bit) INTEGER direct-access binary

BIL4
four-byte (32 bit) INTEGER direct-access binary

FLT or GRIDFLOAT
four-byte (32 bit) REAL direct-access binary

ZBIL
one-byte (8 bit) INTEGER gziped binary

ZBIL2
two-byte (16 bit) INTEGER gziped binary

ZBIL4
four-byte (32 bit) INTEGER gziped binary

ZFLT
four-byte (32 bit) REAL gziped binary

ARCI
ASCII ARC-header-format INTEGER

ARCR and ARCE
ASCII ARC-header-format REAL: ARCR uses fixed-format (xxx.xxxx) formatting, ARCE uses scientific-exponent (x.xxxxEnnn) formatting.

ASCI
ASCII ENVI-header-format INTEGER

ASCR
ASCII ENVI-header-format REAL

where ARCI, ARCR, and ARCR have header lines with one grid parameter name and value per line:
north
south
east
west
rows
cols
while ASCI and ASCR have header lines with one grid parameter per line:
ncols
nrows
xllcorner
yllcorner
cellsize
(optionally) NODATA_value
and *BIL* and *FLT have separate ASCII "header files" to be read and written by the *HDR() routines from this MODULE MODGISIO
Back to Contents

SETSWAP(), BINVERBOSE(), BINTERSE()

SETSWAP(): set byte-swapping flag: 0 for native, 1 for network-to/from-native (normally 0)

BINVERBOSE(): set verbose logging (enabled by default)

BINTERSE(): set non-verbose "terse" logging (disabled by default)

Back to Contents

RDGFHDR()

    LOGICAL FUNCTION RDGFHDR( EQNAME,                           &
                              NCOLS, NROWS, BYTEORDER,          &
                              XLL, YLL, XCELL, YCELL, AMISS )
        CHARACTER(LEN=*), INTENT( IN  ) :: EQNAME    !!  input header-file
        INTEGER,          INTENT( OUT ) :: NCOLS     !!  grid dimensions
        INTEGER,          INTENT( OUT ) :: NROWS     !!
        INTEGER,          INTENT( OUT ) :: BYTEORDER !!
        REAL*8 ,          INTENT( OUT ) :: XLL       !!  lower-left cell-center coords
        REAL*8 ,          INTENT( OUT ) :: YLL       !!
        REAL*8 ,          INTENT( OUT ) :: XCELL     !!  cell-size
        REAL*8 ,          INTENT( OUT ) :: YCELL     !!
        REAL   ,          INTENT( OUT ) :: AMISS     !!  missing-data value
Open, read, and then close the [Z]BIL*/[Z]FLT "header" ASCII file with path-name EQNAME

Back to Contents

WRGFHDR()

    LOGICAL FUNCTION WRGFHDR( GFROOT, VNAME, UNITS, DESCS, VMISS,       &
                              GDTYP, NCOLS, NROWS,                      &
                              P_ALP, P_BET, P_GAM, XCENT, YCENT,        &
                              XORIG, YORIG, XCELL, YCELL )
        CHARACTER(LEN=*), INTENT( IN )::     GFROOT     !  output path
        CHARACTER(LEN=*), INTENT( IN )::     VNAME      !  variable name
        CHARACTER(LEN=*), INTENT( IN )::     UNITS      !  units
        CHARACTER(LEN=*), INTENT( IN )::     DESCS      !  description
        REAL            , INTENT( IN )::     VMISS      !
        INTEGER,          INTENT( IN )::     GDTYP
        INTEGER,          INTENT( IN )::     NCOLS
        INTEGER,          INTENT( IN )::     NROWS
        REAL*8,           INTENT( IN )::     P_ALP
        REAL*8,           INTENT( IN )::     P_BET
        REAL*8,           INTENT( IN )::     P_GAM
        REAL*8,           INTENT( IN )::     XCENT
        REAL*8,           INTENT( IN )::     YCENT
        REAL*8,           INTENT( IN )::     XORIG
        REAL*8,           INTENT( IN )::     YORIG
        REAL*8,           INTENT( IN )::     XCELL
        REAL*8,           INTENT( IN )::     YCELL
Open, write, and close a [Z]BIL*/[Z]FLT "header" ASCII file, containing metadata for matching binary output files for this variable.

Output header file name will be ${GFROOT}/${VNAME}.bil.hdr

Back to Contents

BILHDR()

    LOGICAL FUNCTION BILHDR( BILROOT,                               &
                             VNAME, UNITS, DESCS, SCALE, OFFSET,    &
                             IMISS, NBITS, GDTYP, NCOLS, NROWS,     &
                             P_ALP, P_BET, P_GAM, XCENT, YCENT,     &
                             XORIG, YORIG, XCELL, YCELL )
        CHARACTER(LEN=*), INTENT( IN )::     BILROOT    !  output path
        CHARACTER(LEN=*), INTENT( IN )::     VNAME      !  variablename
        REAL,             INTENT( IN )::     SCALE
        REAL,             INTENT( IN )::     OFFSET
        INTEGER,          INTENT( IN )::     IMISS
        INTEGER,          INTENT( IN )::     NBITS
        CHARACTER(LEN=*), INTENT( IN )::     UNITS      !  units
        CHARACTER(LEN=*), INTENT( IN )::     DESCS      !  description
        INTEGER,          INTENT( IN )::     GDTYP
        INTEGER,          INTENT( IN )::     NCOLS
        INTEGER,          INTENT( IN )::     NROWS
        REAL*8,           INTENT( IN )::     P_ALP
        REAL*8,           INTENT( IN )::     P_BET
        REAL*8,           INTENT( IN )::     P_GAM
        REAL*8,           INTENT( IN )::     XCENT
        REAL*8,           INTENT( IN )::     YCENT
        REAL*8,           INTENT( IN )::     XORIG
        REAL*8,           INTENT( IN )::     YORIG
        REAL*8,           INTENT( IN )::     XCELL
        REAL*8,           INTENT( IN )::     YCELL
Open, write, and close a general scale-and-offset-valued [Z]BIL* "header" ASCII file, containing metadata for matching binary output files for this variable.

Output header file name will be ${GFROOT}/${VNAME}.bil.hdr

Back to Contents

Generic LOGICAL FUNCTION RDAFILE()

    LOGICAL FUNCTION RDAFILE( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, IBUF )
    LOGICAL FUNCTION RDAFILE( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, VBUF )
        CHARACTER(LEN=*), INTENT(  IN ) :: FNAME
        INTEGER         , INTENT(  IN ) :: NCOLS, NROWS
        REAL*8          , INTENT(  IN ) :: XORIG, YORIG, ACELL
        INTEGER         , INTENT( OUT ) :: IBUF( NCOLS, NROWS )
        REAL            , INTENT( OUT ) :: VBUF( NCOLS, NROWS )
Open the ASC-format (internal 7-line header) ASCII file with logical name FNAME for input.

Read its header and check for consistency with the supplied argument grid description.

Read the data into IBUF or VBUF from the file.

Returns .TRUE. iff all these operations succeed.

Back to Contents

Generic LOGICAL FUNCTION WRAFILE() and LOGICAL FUNCTION WRAEFILE()

    LOGICAL FUNCTION WRAFILE(  FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, IBUF )
    LOGICAL FUNCTION WRAFILE(  FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, VBUF )
    LOGICAL FUNCTION WRAEFILE( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, VBUF )
        CHARACTER(LEN=*), INTENT( IN ) :: FNAME
        INTEGER         , INTENT( IN ) :: NCOLS, NROWS
        REAL*8          , INTENT( IN ) :: XORIG, YORIG, ACELL
        INTEGER         , INTENT( IN ) :: IBUF( NCOLS, NROWS )
        REAL            , INTENT( IN ) :: VBUF( NCOLS, NROWS )
Open the ASC-format (internal 7-line header) ASCII file with logical name FNAME for output.

Write its header using the supplied grid description arguments.

Write the data from IBUF or VBUF to the file. For WRAEFILE(), use a format 1PE14.6 for the (REAL) data in the output; else use a format F12.5 if the data is REAL.

Returns .TRUE. iff all these operations succeed.

Back to Contents

Generic SUBROUTINE RDARC()

    LOGICAL FUNCTION RDARC( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, IBUF )
    LOGICAL FUNCTION RDARC( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, VBUF )
        CHARACTER(LEN=*), INTENT(  IN ) :: FNAME
        INTEGER         , INTENT(  IN ) :: NCOLS, NROWS
        REAL*8          , INTENT(  IN ) :: XORIG, YORIG, ACELL
        INTEGER         , INTENT( OUT ) :: IBUF( NCOLS, NROWS )
        REAL            , INTENT( OUT ) :: VBUF( NCOLS, NROWS )
Open the ARC-format (external header) ARCII GIS-output file with logical name FNAME for input.

Read its header and check for consistency with the supplied argument grid description.

Read the data into IBUF or VBUF from the file.

Returns .TRUE. iff all these operations succeed.

Back to Contents

Generic SUBROUTINE WRARC()

    LOGICAL FUNCTION WRARC( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, IBUF )
    LOGICAL FUNCTION WRARC( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, VBUF )
        CHARACTER(LEN=*), INTENT( IN ) :: FNAME
        INTEGER         , INTENT( IN ) :: NCOLS, NROWS
        REAL*8          , INTENT( IN ) :: XORIG, YORIG, ACELL
        INTEGER         , INTENT( IN ) :: IBUF( NCOLS, NROWS )
        REAL            , INTENT( IN ) :: VBUF( NCOLS, NROWS )
Open the ARC-format (external header) ARCII GIS-output file with logical name FNAME for output.

Write its header using the supplied grid description arguments.

Write the data from IBUF or VBUF to the file.

Returns .TRUE. iff all these operations succeed.

Back to Contents

LOGICAL FUNCTIONs RDBRFILE() and RDZBRFILE()

    LOGICAL FUNCTION RDBRFILE(  FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, VBUF )
    LOGICAL FUNCTION RDZBRFILE( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, VBUF )
        CHARACTER(LEN=*), INTENT(  IN ) :: FNAME
        INTEGER         , INTENT(  IN ) :: NCOLS, NROWS
        REAL*8          , INTENT(  IN ) :: XORIG, YORIG, ACELL
        REAL            , INTENT( OUT ) :: VBUF( NCOLS, NROWS )
Open the binary GRIDFLOAT file or gzipped GRIDFLOAT file with logical name FNAME for input.

Read its header and check for consistency with the supplied argument grid description.

Read the data into VBUF from the file. For RDZBRFILE(), apply on-the-fly unzipping.

Returns .TRUE. iff all these operations succeed.

Back to Contents

LOGICAL FUNCTIONs WRBRFILE() and WRZBRFILE()

    LOGICAL FUNCTION WRBRFILE(  FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, VBUF )
    LOGICAL FUNCTION WRZBRFILE( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, VBUF )
        CHARACTER(LEN=*), INTENT( IN ) :: FNAME
        INTEGER         , INTENT( IN ) :: NCOLS, NROWS
        REAL*8          , INTENT( IN ) :: XORIG, YORIG, ACELL
        REAL            , INTENT( IN ) :: VBUF( NCOLS, NROWS )
Open the binary GRIDFLOAT file or gzipped GRIDFLOAT file with logical name FNAME for output.

Write the data from VBUF top the file with on-the-fly zipping for WRZBRFILE())

Returns .TRUE. iff all these operations succeed.

Back to Contents

Generic LOGICAL FUNCTION RDBIFILE() and RDZBIFILE()

    LOGICAL FUNCTION RDBIFILE(  FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I1BUF )
    LOGICAL FUNCTION RDBIFILE(  FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I2BUF )
    LOGICAL FUNCTION RDBIFILE(  FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I4BUF )
    LOGICAL FUNCTION RDZBIFILE( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I1BUF )
    LOGICAL FUNCTION RDZBIFILE( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I2BUF )
    LOGICAL FUNCTION RDZBIFILE( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I4BUF )
        CHARACTER(LEN=*), INTENT(  IN ) :: FNAME
        INTEGER         , INTENT(  IN ) :: NCOLS, NROWS
        REAL*8          , INTENT(  IN ) :: XORIG, YORIG, ACELL
        INTEGER*1       , INTENT( OUT ) :: I1BUF( NCOLS, NROWS )
        INTEGER*2       , INTENT( OUT ) :: I2BUF( NCOLS, NROWS )
        INTEGER*4       , INTENT( OUT ) :: I4BUF( NCOLS, NROWS )
Open the binary (8-bit) BIL1 GIS file or gzipped with logical name FNAME for input.

Read its header and check for consistency with the supplied argument grid description.

Read and convert the data from the file to I1BUF I2BUF I4BUF as appropriate. For the RDZ*() routines, apply on-the-fly unzipping.

Returns .TRUE. iff all these operations succeed.

Back to Contents

Generic LOGICAL FUNCTION RDBI2FILE() and RDZBI2FILE()

    LOGICAL FUNCTION RDBI2FILE(  FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I2BUF )
    LOGICAL FUNCTION RDBI2FILE(  FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I4BUF )
    LOGICAL FUNCTION RDZBI2FILE( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I2BUF )
    LOGICAL FUNCTION RDZBI2FILE( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I4BUF )
        CHARACTER(LEN=*), INTENT(  IN ) :: FNAME
        INTEGER         , INTENT(  IN ) :: NCOLS, NROWS
        REAL*8          , INTENT(  IN ) :: XORIG, YORIG, ACELL
        INTEGER*2       , INTENT( OUT ) :: I2BUF( NCOLS, NROWS )
        INTEGER*4       , INTENT( OUT ) :: I4BUF( NCOLS, NROWS )
Open the binary (16-bit) BIL2 GIS file with logical name FNAME for input.

Read its header and check for consistency with the supplied argument grid description.

Read and convert the data from the file to I2BUF I4BUF as appropriate. For the RDZ*() routines, apply on-the-fly unzipping.

Returns .TRUE. iff all these operations succeed.

Back to Contents

LOGICAL FUNCTION RDBI4FILE() and RDZBI4FILE()

    LOGICAL FUNCTION RDBI4FILE(  FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I4BUF )
    LOGICAL FUNCTION RDZBI4FILE( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I4BUF )
        CHARACTER(LEN=*), INTENT(  IN ) :: FNAME
        INTEGER         , INTENT(  IN ) :: NCOLS, NROWS
        REAL*8          , INTENT(  IN ) :: XORIG, YORIG, ACELL
        INTEGER*4       , INTENT( OUT ) :: I4BUF( NCOLS, NROWS )
Open the binary (32-bit) BIL4 GIS file with logical name FNAME for input.

Read its header and check for consistency with the supplied argument grid description.

Read the data from the file to I4BUF. For the RDZ*() routines, apply on-the-fly unzipping.

Returns .TRUE. iff all these operations succeed.

Back to Contents

Generic LOGICAL FUNCTION WRBIFILE() and WRZBIFILE()

    LOGICAL FUNCTION WRBIFILE(  FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I1BUF )
    LOGICAL FUNCTION WRBIFILE(  FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I2BUF )
    LOGICAL FUNCTION WRBIFILE(  FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I4BUF )
    LOGICAL FUNCTION WRZBIFILE( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I1BUF )
    LOGICAL FUNCTION WRZBIFILE( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I2BUF )
    LOGICAL FUNCTION WRZBIFILE( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I4BUF )
        CHARACTER(LEN=*), INTENT(  IN ) :: FNAME
        INTEGER         , INTENT(  IN ) :: NCOLS, NROWS
        REAL*8          , INTENT(  IN ) :: XORIG, YORIG, ACELL
        INTEGER*1       , INTENT( OUT ) :: I1BUF( NCOLS, NROWS )
        INTEGER*2       , INTENT( OUT ) :: I2BUF( NCOLS, NROWS )
        INTEGER*4       , INTENT( OUT ) :: I4BUF( NCOLS, NROWS )
Open the binary (8-bit) BIL1 GIS file with logical name FNAME for output.

Convert and write the data from I1BUF, I2BUF, or I4BUF as appropriate to the file. For the WRZ*() routines, apply on-the-fly zipping.

Returns .TRUE. iff all these operations succeed.

Back to Contents

Generic LOGICAL FUNCTION WRBI2FILE() and WRZBI2FILE()

    LOGICAL FUNCTION WRBI2FILE(  FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I2BUF )
    LOGICAL FUNCTION WRBI2FILE(  FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I4BUF )
    LOGICAL FUNCTION WRZBI2FILE( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I2BUF )
    LOGICAL FUNCTION WRZBI2FILE( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I4BUF )
        CHARACTER(LEN=*), INTENT( IN ) :: FNAME
        INTEGER         , INTENT( IN ) :: NCOLS, NROWS
        REAL*8          , INTENT( IN ) :: XORIG, YORIG, ACELL
        INTEGER*2       , INTENT( IN ) :: I2BUF( NCOLS, NROWS )
        INTEGER*4       , INTENT( IN ) :: I4BUF( NCOLS, NROWS )
Open the binary (16-bit) BIL2 GIS file with logical name FNAME for output.

Convert and write the data from I2BUF or I4BUF as appropriate to the file. For the WRZ*() routines, apply on-the-fly zipping.

Returns .TRUE. iff all these operations succeed.

Back to Contents

LOGICAL FUNCTION WRBI4FILE() and WRZBI4FILE()

    LOGICAL FUNCTION WRBI4FILE(  FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I4BUF )
    LOGICAL FUNCTION WRZBI4FILE( FNAME, NCOLS, NROWS, XORIG, YORIG, ACELL, I4BUF )
        CHARACTER(LEN=*), INTENT( IN ) :: FNAME
        INTEGER         , INTENT( IN ) :: NCOLS, NROWS
        REAL*8          , INTENT( IN ) :: XORIG, YORIG, ACELL
        INTEGER*4       , INTENT( IN ) :: I4BUF( NCOLS, NROWS )
Open the binary (32-bit) BIL4 GIS file with logical name FNAME for output.

Write the data from I4BUF to the file. For the WRZ*() routines, apply on-the-fly unzipping.

Returns .TRUE. iff all these operations succeed.

Back to Contents

Worker routines from gisio.c

These routines do not transpose between GIS "scan-line" (XCELL>0, YCELL<0) array order and "normal-model" (XCELL,YCELL>0) array order but do convert between network (big-endian) and native (usually little-endian) byte order, according to the value of argument SWAPB (0 for no conversion, 1 for conversion). 

    !!--------  Prototypes for routines in "gridbin.c"  -----------
    !!--------  SWAPB:  0 for native byte order; else call "htonl()"

    INTERFACE
        INTEGER FUNCTION GFREAD( GFILE, NCOLS, NROWS, SWAPB, GBUF )
        CHARACTER(LEN=*), INTENT( IN ) ::   GFILE
        INTEGER,          INTENT( IN ) ::   NCOLS, NROWS
        INTEGER,          INTENT( IN ) ::   SWAPB
        REAL   ,          INTENT( OUT) ::   GBUF( NCOLS*NROWS )
        END FUNCTION GFREAD
    END INTERFACE

    INTERFACE
        INTEGER FUNCTION GFZREAD( GFILE, NCOLS, NROWS, SWAPB, GBUF )
        CHARACTER(LEN=*), INTENT( IN ) ::   GFILE
        INTEGER,          INTENT( IN ) ::   NCOLS, NROWS
        INTEGER,          INTENT( IN ) ::   SWAPB
        REAL   ,          INTENT( OUT) ::   GBUF( NCOLS*NROWS )
        END FUNCTION GFZREAD
    END INTERFACE

    INTERFACE
        INTEGER FUNCTION GFWRITE( GFILE, NCOLS, NROWS, SWAPB, GBUF )
        CHARACTER(LEN=*), INTENT( IN ) ::   GFILE
        INTEGER,          INTENT( IN ) ::   NCOLS, NROWS, SWAPB
        REAL   ,          INTENT( IN ) ::   GBUF( NCOLS*NROWS )
        END FUNCTION GFWRITE
    END INTERFACE

    INTERFACE
        INTEGER FUNCTION GFZWRITE( GFILE, NCOLS, NROWS, SWAPB, GBUF )
        CHARACTER(LEN=*), INTENT( IN ) ::   GFILE
        INTEGER,          INTENT( IN ) ::   NCOLS, NROWS, SWAPB
        REAL   ,          INTENT( IN ) ::   GBUF( NCOLS*NROWS )
        END FUNCTION GFZWRITE
    END INTERFACE

    INTERFACE
        INTEGER FUNCTION ZBILWRITE( BFILE, NCOLS, NROWS, GBUF )
        CHARACTER(LEN=*), INTENT( IN ) ::   BFILE
        INTEGER,          INTENT( IN ) ::   NCOLS, NROWS
        INTEGER*1,        INTENT( IN ) ::   GBUF( NCOLS*NROWS )
        END FUNCTION ZBILWRITE
    END INTERFACE

    INTERFACE
        INTEGER FUNCTION BILWRITE( BFILE, NCOLS, NROWS, GBUF )
        CHARACTER(LEN=*), INTENT( IN ) ::   BFILE
        INTEGER,          INTENT( IN ) ::   NCOLS, NROWS
        INTEGER*1,        INTENT( IN ) ::   GBUF( NCOLS*NROWS )
        END FUNCTION BILWRITE
    END INTERFACE

    INTERFACE
        INTEGER FUNCTION ZBILREAD( BFILE, NCOLS, NROWS, GBUF )
        CHARACTER(LEN=*), INTENT( IN ) ::   BFILE
        INTEGER,          INTENT( IN ) ::   NCOLS, NROWS
        INTEGER*1,        INTENT( OUT) ::   GBUF( NCOLS*NROWS )
        END FUNCTION ZBILREAD
    END INTERFACE

    INTERFACE
        INTEGER FUNCTION BILREAD( BFILE, NCOLS, NROWS, GBUF )
        CHARACTER(LEN=*), INTENT( IN ) ::   BFILE
        INTEGER,          INTENT( IN ) ::   NCOLS, NROWS
        INTEGER*1,        INTENT( OUT) ::   GBUF( NCOLS*NROWS )
        END FUNCTION BILREAD
    END INTERFACE

    INTERFACE
        INTEGER FUNCTION ZBIL2WRITE( BFILE, NCOLS, NROWS, SWAPB, GBUF )
        CHARACTER(LEN=*), INTENT( IN ) ::   BFILE
        INTEGER,          INTENT( IN ) ::   NCOLS, NROWS, SWAPB
        INTEGER*2,        INTENT( IN ) ::   GBUF( NCOLS*NROWS )
        END FUNCTION ZBIL2WRITE
    END INTERFACE

    INTERFACE
        INTEGER FUNCTION BIL2WRITE( BFILE, NCOLS, NROWS, SWAPB, GBUF )
        CHARACTER(LEN=*), INTENT( IN ) ::   BFILE
        INTEGER,          INTENT( IN ) ::   NCOLS, NROWS, SWAPB
        INTEGER*2,        INTENT( IN ) ::   GBUF( NCOLS*NROWS )
        END FUNCTION BIL2WRITE
    END INTERFACE

    INTERFACE
        INTEGER FUNCTION ZBIL2READ( BFILE, NCOLS, NROWS, SWAPB, GBUF )
        CHARACTER(LEN=*), INTENT( IN ) ::   BFILE
        INTEGER,          INTENT( IN ) ::   NCOLS, NROWS, SWAPB
        INTEGER*2,        INTENT( OUT) ::   GBUF( NCOLS*NROWS )
        END FUNCTION ZBIL2READ
    END INTERFACE

    INTERFACE
        INTEGER FUNCTION BIL2READ( BFILE, NCOLS, NROWS, SWAPB, GBUF )
        CHARACTER(LEN=*), INTENT( IN ) ::   BFILE
        INTEGER,          INTENT( IN ) ::   NCOLS, NROWS, SWAPB
        INTEGER*2,        INTENT( OUT) ::   GBUF( NCOLS*NROWS )
        END FUNCTION BIL2READ
    END INTERFACE

    INTERFACE
        INTEGER FUNCTION ZBIL4WRITE( BFILE, NCOLS, NROWS, SWAPB, GBUF )
        CHARACTER(LEN=*), INTENT( IN ) ::   BFILE
        INTEGER,          INTENT( IN ) ::   NCOLS, NROWS, SWAPB
        INTEGER*4,        INTENT( IN ) ::   GBUF( NCOLS*NROWS )
        END FUNCTION ZBIL4WRITE
    END INTERFACE

    INTERFACE
        INTEGER FUNCTION BIL4WRITE( BFILE, NCOLS, NROWS, SWAPB, GBUF )
        CHARACTER(LEN=*), INTENT( IN ) ::   BFILE
        INTEGER,          INTENT( IN ) ::   NCOLS, NROWS, SWAPB
        INTEGER*4,        INTENT( IN ) ::   GBUF( NCOLS*NROWS )
        END FUNCTION BIL4WRITE
    END INTERFACE

    INTERFACE
        INTEGER FUNCTION ZBIL4READ( BFILE, NCOLS, NROWS, SWAPB, GBUF )
        CHARACTER(LEN=*), INTENT( IN ) ::   BFILE
        INTEGER,          INTENT( IN ) ::   NCOLS, NROWS, SWAPB
        INTEGER*4,        INTENT( OUT) ::   GBUF( NCOLS*NROWS )
        END FUNCTION ZBIL4READ
    END INTERFACE

    INTERFACE
        INTEGER FUNCTION BIL4READ( BFILE, NCOLS, NROWS, SWAPB, GBUF )
        CHARACTER(LEN=*), INTENT( IN ) ::   BFILE
        INTEGER,          INTENT( IN ) ::   NCOLS, NROWS, SWAPB
        INTEGER*4,        INTENT( OUT) ::   GBUF( NCOLS*NROWS )
        END FUNCTION BIL4READ
    END INTERFACE
Back to Contents

See Also:
To: Models-3/EDSS I/O API: The Help Pages

Up: MODULEs and Public INCLUDE files

Copyright © 2025 Carlie J. Coats, Jr., Ph.D.

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.

Send comments to

Carlie J. Coats, Jr.
carlie@jyarborough.com