/*
 * The Npic library
 *
 * Copyright (C) 2003 Edouard Thiel <Edouard.Thiel@lif.univ-mrs.fr>
 *
 * This library is free software under the terms of the 
 * GNU Lesser General Public License (LGPL) version 2.1.
*/

/* DO NOT EDIT !!!  Generated by npic-templa from "files_pan.ct" */

/*
 * files_pan.c - 07/12/2007
 *
 * PAN - multidimensionnal image format from Pandore library
 *
 * see http://www.greyc.ensicaen.fr/EquipeImage/Pandore/
*/


#include <npic.h>

#define MAXBUF 65536

#define FBUF_INT8   4096
#define FBUF_INT16  2048
#define FBUF_INT32  1024
#define FBUF_FLOAT  1024


/*--------------------- P U B L I C - I N T E R F A C E ----------------------*/

/*
 * Save Npic_image image in a file in PAN format.
 * If comp != NPIC_COMPRESS_NONE, the file is directly compressed using
 * the appropriate command (see files_hints.h for available formats).
 * Do nothing if image is not ok.
 *
 * Return NPIC_SUCCESS, else error code. Verbose.
 *
 * USAGE :
 *    Npic_image *np; int err;
 *    ...
 *    err = NpicWritePAN (&np, "example.pan"   , NPIC_COMPRESS_NONE);
 * or err = NpicWritePAN (&np, "example.pan.gz", NPIC_COMPRESS_GZ);
 *    if (err < 0) return err;
 *    ....
 *    NpicDestroyImage (np);
*/

int NpicWritePAN (Npic_image *np, const char *filename, Npic_file_compress comp)
{
    Npic_file_gz fgz;
    
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS)
        return NPIC_ERR_NOT_OK;

    NpicWriteGZ_Open (&fgz, filename, __func__, 0, comp);
    
    if (fgz.res == NPIC_SUCCESS) 
        fgz.res = NpicPANWriteFile (np, fgz.f2, filename, __func__);

    NpicWriteGZ_Close (&fgz);
    return fgz.res;
}


/*
 * Read image file in PAN format and create Npic_image image. 
 * If comp != NPIC_COMPRESS_NONE, the file is uncompressed in memory using
 * the appropriate command (but stay compressed on disk).
 * Return image on success, else return NULL. Verbose.
 *
 * USAGE :
 *    Npic_image *np;
 *    np = NpicReadPAN ("example.pan"   , NPIC_COMPRESS_NONE);
 * or np = NpicReadPAN ("example.pan.gz", NPIC_COMPRESS_GZ);
 *    if (np == NULL) return;
 *    ....
 *    NpicDestroyImage (np);
*/

Npic_image *NpicReadPAN (const char *filename, Npic_file_compress comp)
{
    Npic_image *np = NULL;
    Npic_file_gz fgz;

    NpicReadGZ_Open (&fgz, filename, __func__, 0, comp);
    
    if (fgz.res == NPIC_SUCCESS) 
        np = NpicPANReadFile (fgz.f2, filename, __func__);
        
    NpicReadGZ_Close (&fgz);
    return np;
}


/*
 * Print infos of a (maybe compressed) file in PAN format
 *
 * Return NPIC_SUCCESS, else error code. Verbose.
*/

int NpicInfoPAN (const char *filename, Npic_file_compress comp)
{
    Npic_file_gz fgz;
    Npic_pan_info info;

    NpicReadGZ_Open (&fgz, filename, __func__, 0, comp);
   
    if (fgz.res == NPIC_SUCCESS) {
        fgz.res = NPicPANReadInfo (fgz.f2, &info);
        if (fgz.res == NPIC_SUCCESS)
            fgz.res = NpicPANPrintInfo (filename, &info);
        NpicError (__func__, fgz.res, ": file \"%s\"", filename);
    }

    NpicReadGZ_Close (&fgz);
    return fgz.res;
}


/*-------------------- P R I V A T E - F U N C T I O N S ---------------------*/

/*
 * Save Npic_image image in a file in PAN format.
 * The file is already fopen.
 * Return NPIC_SUCCESS, else error code. Verbose.
*/

int NpicPANWriteFile (Npic_image *np, FILE *f1, const char *filename, const char *funcname)
{
    int k, nattr;
    Npic_pan_header header;
    Npic_sint32 attr[16];
    time_t tt1;
    struct tm *tm1;
    char line[1024];

    if (NpicImageIsOK (np, funcname) != NPIC_SUCCESS)
        return NPIC_ERR_NOT_OK;

    /*
     * Header
    */
    memset (&header, 0, sizeof(Npic_pan_header));
    strncpy (header.magic, NPIC_PAN_MAGIC, sizeof (header.magic));
    
    switch (np->type) {
        case NPIC_IMAGE_2C : header.potype = NPIC_PAN_Img2duc  ; break;
        case NPIC_IMAGE_2L : header.potype = NPIC_PAN_Img2dsl  ; break;
        case NPIC_IMAGE_2D : header.potype = NPIC_PAN_Img2dsf  ; break;
        case NPIC_IMAGE_2Q : header.potype = NPIC_PAN4_Imx2dul ; break;   
        case NPIC_IMAGE_3C : header.potype = NPIC_PAN_Img3duc  ; break;
        case NPIC_IMAGE_3L : header.potype = NPIC_PAN_Img3dsl  ; break;
        case NPIC_IMAGE_3D : header.potype = NPIC_PAN_Img3dsf  ; break;
        case NPIC_IMAGE_3Q : header.potype = NPIC_PAN4_Imx3dul ; break;   
        case NPIC_IMAGE_4C : header.potype = NPIC_PAN_Imx3duc  ; break;
        case NPIC_IMAGE_4L : header.potype = NPIC_PAN_Imx3dsl  ; break;
        case NPIC_IMAGE_4D : header.potype = NPIC_PAN_Imx3dsf  ; break;
        default : 
            return NpicError (__func__, NPIC_ERR_UNEX_NPIC, ": potype");
    }
    
    strncpy (header.ident, __func__, sizeof (header.ident));
    
    /* Write date as "007/12/31" : the first '2' do not appear. */    
    time(&tt1);
    tm1 = localtime (&tt1);
    sprintf (line, "%d/%d/%d", tm1->tm_year+1900, tm1->tm_mon+1, tm1->tm_mday);
    /* printf ("Date is \"%s\"\n", line+1); */
    strncpy (header.date, line+1, sizeof (header.date));

    /* Write the header */
    k = fwrite (&header, sizeof(header), 1, f1);
    if (k != 1) 
        return NpicError (funcname, NPIC_ERR_WRITE, ": file \"%s\"", filename);

    /*
     * Attributes : adapted from pandore:include/image.h
    */
    nattr = 0;
    switch (np->type) {
        case NPIC_IMAGE_2C : 
        case NPIC_IMAGE_2L :
        case NPIC_IMAGE_2D :
        case NPIC_IMAGE_2Q :     
            attr[nattr++] = (np->type == NPIC_IMAGE_2Q) ? 4 : 1;
            attr[nattr++] = np->gen.ymax;
            attr[nattr++] = np->gen.xmax;
            break;
        case NPIC_IMAGE_3C :
        case NPIC_IMAGE_3L :
        case NPIC_IMAGE_3D :
        case NPIC_IMAGE_3Q :     
            attr[nattr++] = (np->type == NPIC_IMAGE_3Q) ? 4 : 1;
            attr[nattr++] = np->gen.zmax;
            attr[nattr++] = np->gen.ymax;
            attr[nattr++] = np->gen.xmax;
            break;
        case NPIC_IMAGE_4C :
        case NPIC_IMAGE_4L :
        case NPIC_IMAGE_4D :
            attr[nattr++] = np->gen.tmax;
            attr[nattr++] = np->gen.zmax;
            attr[nattr++] = np->gen.ymax;
            attr[nattr++] = np->gen.xmax;
            break;
        default : 
            return NpicError (__func__, NPIC_ERR_UNEX_NPIC, ": attribute");
    }
    
    /* Write attributes */
    k = fwrite (attr, sizeof(Npic_sint32), nattr, f1);
    if (k != nattr) 
        return NpicError (funcname, NPIC_ERR_WRITE, ": file \"%s\"", filename);

    /*
     * Datas
    */
    switch (np->type) {

        case NPIC_IMAGE_2D : {
            int x, y, j;
            float  h, buf[FBUF_FLOAT]; 
            Npic_image_2d *I = NpicCastImage(np);

            j = 0;
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                buf[j++] = I->pix[y][x];
                if (j == FBUF_FLOAT) {
                    k = fwrite (buf, j*sizeof(h), 1, f1);
                    if (k != 1) return NPIC_ERR_WRITE;
                    j = 0;
                }
            }
            
            /* Flush buf */
            if (j > 0) {
                k = fwrite (buf, j*sizeof(h), 1, f1);
                if (k != 1) return NPIC_ERR_WRITE;
            }
        } break;

        case NPIC_IMAGE_3D : {
            int x, y, z, j;
            float  h, buf[FBUF_FLOAT]; 
            Npic_image_3d *I = NpicCastImage(np);

            j = 0;
            for (z = 0; z < I->zmax; z++)
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                buf[j++] = I->pix[z][y][x];
                if (j == FBUF_FLOAT) {
                    k = fwrite (buf, j*sizeof(h), 1, f1);
                    if (k != 1) return NPIC_ERR_WRITE;
                    j = 0;
                }
            }
            
            /* Flush buf */
            if (j > 0) {
                k = fwrite (buf, j*sizeof(h), 1, f1);
                if (k != 1) return NPIC_ERR_WRITE;
            }
        } break;

        case NPIC_IMAGE_4D : {
            int x, y, z, t, j;
            float  h, buf[FBUF_FLOAT]; 
            Npic_image_4d *I = NpicCastImage(np);

            j = 0;
            for (t = 0; t < I->tmax; t++)
            for (z = 0; z < I->zmax; z++)
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                buf[j++] = I->pix[t][z][y][x];
                if (j == FBUF_FLOAT) {
                    k = fwrite (buf, j*sizeof(h), 1, f1);
                    if (k != 1) return NPIC_ERR_WRITE;
                    j = 0;
                }
            }
            
            /* Flush buf */
            if (j > 0) {
                k = fwrite (buf, j*sizeof(h), 1, f1);
                if (k != 1) return NPIC_ERR_WRITE;
            }
        } break;

        case NPIC_IMAGE_2Q : {  /* NPIC_PAN4_Imx2dul */
            int y, x, j;
            Npic_l  h, buf[FBUF_INT32];
            Npic_image_2q *I = NpicCastImage(np);

            j = 0;
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                buf[j++] = I->pix[y][x].a << 16;
                if (j >= FBUF_INT32) {
                    k = fwrite (buf, j*sizeof(h), 1, f1);
                    if (k != 1) return NPIC_ERR_WRITE;
                    j = 0;
                }
            }
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                buf[j++] = I->pix[y][x].b << 16;
                if (j >= FBUF_INT32) {
                    k = fwrite (buf, j*sizeof(h), 1, f1);
                    if (k != 1) return NPIC_ERR_WRITE;
                    j = 0;
                }
            }
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                buf[j++] = I->pix[y][x].c << 16;
                if (j >= FBUF_INT32) {
                    k = fwrite (buf, j*sizeof(h), 1, f1);
                    if (k != 1) return NPIC_ERR_WRITE;
                    j = 0;
                }
            }
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                buf[j++] = I->pix[y][x].d << 16;
                if (j >= FBUF_INT32) {
                    k = fwrite (buf, j*sizeof(h), 1, f1);
                    if (k != 1) return NPIC_ERR_WRITE;
                    j = 0;
                }
            }
            
            /* Flush buf */
            if (j > 0) {
                k = fwrite (buf, j*sizeof(h), 1, f1);
                if (k != 1) return NPIC_ERR_WRITE;
            }
        } break;

        case NPIC_IMAGE_3Q : {  /* NPIC_PAN4_Imx3dul */
            int z, y, x, j;
            Npic_l  h, buf[FBUF_INT32];
            Npic_image_3q *I = NpicCastImage(np);

            j = 0;
            for (z = 0; z < I->zmax; z++)
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                buf[j++] = I->pix[z][y][x].a << 16;
                if (j >= FBUF_INT32) {
                    k = fwrite (buf, j*sizeof(h), 1, f1);
                    if (k != 1) return NPIC_ERR_WRITE;
                    j = 0;
                }
            }
            for (z = 0; z < I->zmax; z++)
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                buf[j++] = I->pix[z][y][x].b << 16;
                if (j >= FBUF_INT32) {
                    k = fwrite (buf, j*sizeof(h), 1, f1);
                    if (k != 1) return NPIC_ERR_WRITE;
                    j = 0;
                }
            }
            for (z = 0; z < I->zmax; z++)
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                buf[j++] = I->pix[z][y][x].c << 16;
                if (j >= FBUF_INT32) {
                    k = fwrite (buf, j*sizeof(h), 1, f1);
                    if (k != 1) return NPIC_ERR_WRITE;
                    j = 0;
                }
            }
            for (z = 0; z < I->zmax; z++)
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                buf[j++] = I->pix[z][y][x].d << 16;
                if (j >= FBUF_INT32) {
                    k = fwrite (buf, j*sizeof(h), 1, f1);
                    if (k != 1) return NPIC_ERR_WRITE;
                    j = 0;
                }
            }
            
            /* Flush buf */
            if (j > 0) {
                k = fwrite (buf, j*sizeof(h), 1, f1);
                if (k != 1) return NPIC_ERR_WRITE;
            }
        } break;

        default : return NpicWriteRAW (np, f1, 0);
    }

    return NPIC_SUCCESS;
}


/*
 * Read image file in PAN format and create Npic_image image. 
 * The file is already fopen.
 * Return image on success, else return NULL. Verbose.
*/

Npic_image *NpicPANReadFile (FILE *f1, const char *filename, const char *funcname)
{
    Npic_image *np = NULL;
    Npic_pan_info info;
    int k;
 
    k = NPicPANReadInfo (f1, &info);
    if (k != NPIC_SUCCESS) {
        NpicError (funcname, k, ": file \"%s\"", filename);
        return NULL;
    }
    
    /* Create image */
    switch (info.npic_type) {
        case NPIC_IMAGE_2C :
            np = NpicCreateImage_2c (info.nrow, info.ncol, 0, 0); break;
        case NPIC_IMAGE_2L :
            np = NpicCreateImage_2l (info.nrow, info.ncol, 0, 0); break;
        case NPIC_IMAGE_2D :
            np = NpicCreateImage_2d (info.nrow, info.ncol, 0, 0); break;
        case NPIC_IMAGE_2Q :
            np = NpicCreateImage_2q (info.nrow, info.ncol, 0, 0); break;
        case NPIC_IMAGE_3C :
            np = NpicCreateImage_3c (info.ndep, info.nrow, info.ncol, 0, 0, 0); break;
        case NPIC_IMAGE_3L :
            np = NpicCreateImage_3l (info.ndep, info.nrow, info.ncol, 0, 0, 0); break;
        case NPIC_IMAGE_3D :
            np = NpicCreateImage_3d (info.ndep, info.nrow, info.ncol, 0, 0, 0); break;
        case NPIC_IMAGE_3Q :
            np = NpicCreateImage_3q (info.ndep, info.nrow, info.ncol, 0, 0, 0); break;
        case NPIC_IMAGE_4C :
            np = NpicCreateImage_4c (info.nband, info.ndep, info.nrow, info.ncol, 0, 0, 0, 0); break;
        case NPIC_IMAGE_4L :
            np = NpicCreateImage_4l (info.nband, info.ndep, info.nrow, info.ncol, 0, 0, 0, 0); break;
        case NPIC_IMAGE_4D :
            np = NpicCreateImage_4d (info.nband, info.ndep, info.nrow, info.ncol, 0, 0, 0, 0); break;
        default :
            NpicError (funcname, NPIC_ERR_UNEX_NPIC, ": file \"%s\"", filename);
            return NULL;
    }
    
    if (np == NULL) {
        NpicError (funcname, NPIC_ERROR, ": file \"%s\"", filename);
        return NULL;
    }
    
    k = NpicPANReadDatas (np, f1, info.swap);
    if (k != NPIC_SUCCESS) {
        NpicDestroyImage (np); np = NULL; 
        NpicError (funcname, k, ": file \"%s\"", filename);
    }

    return np;
}    
 
    
/*
 * Read infos (i.e binary header + attributes) in a PAN file,
 * then store results in struct info. 
 * The file is already fopen.
 * Return NPIC_SUCCESS, else error code. Silent.
*/

int NPicPANReadInfo (FILE *f1, Npic_pan_info *info)
{
    Npic_pan_header header;
    int k, nattr;
    Npic_sint32 attr[16];
    
    if (f1 == NULL) return NPIC_ERR_BAD_FD;
    if (info == NULL) return NPIC_ERR_NULL_PTR;

    memset (info, 0, sizeof(Npic_pan_info));
    
    k = fread (&header, sizeof (header), 1, f1);
    if (k != 1) return NPIC_ERR_READ;
    
    strncpy (info->magic, header.magic, sizeof (header.magic));
    if (strncmp (info->magic, NPIC_PAN_MAGIC, 7) != 0)
        return NPIC_ERR_MAGIC;

    info->potype = header.potype; info->swap = 0;
    if (info->potype > 255) {
        info->potype = NPIC_BSWAP32(info->potype); info->swap = 1;
        if (info->potype > 255) return NPIC_ERR_ENDIAN;
    }

    strncpy (info->date, header.date, sizeof (header.date));
    strncpy (info->ident, header.ident, sizeof (header.ident));
    
    /* Get nattr */
    switch (info->potype) {
        case NPIC_PAN_Img2duc : 
        case NPIC_PAN_Img2dsl : 
        case NPIC_PAN_Img2dsf : 
        case NPIC_PAN4_Imx2dul: nattr = 3; break;
        
        case NPIC_PAN_Img3duc : 
        case NPIC_PAN_Img3dsl : 
        case NPIC_PAN_Img3dsf : 
        case NPIC_PAN_Imx3duc : 
        case NPIC_PAN_Imx3dsl : 
        case NPIC_PAN_Imx3dsf : 
        case NPIC_PAN4_Imx3dul: nattr = 4; break;
        
        default : return NPIC_ERR_UNEX_TYPE;
    }
    
    /* Read attributes */
    k = fread (attr, sizeof(Npic_sint32), nattr, f1);
    if (k != nattr) return NPIC_ERR_READ;

    switch (info->potype) {
        case NPIC_PAN_Img2duc : 
        case NPIC_PAN_Img2dsl : 
        case NPIC_PAN_Img2dsf : 
        case NPIC_PAN4_Imx2dul: 
            info->nband = info->swap ? NPIC_BSWAP32(attr[0]) : attr[0]; 
            info->ndep  = 1; 
            info->nrow  = info->swap ? NPIC_BSWAP32(attr[1]) : attr[1]; 
            info->ncol  = info->swap ? NPIC_BSWAP32(attr[2]) : attr[2]; 
            break;
        case NPIC_PAN_Img3duc : 
        case NPIC_PAN_Img3dsl : 
        case NPIC_PAN_Img3dsf : 
        case NPIC_PAN_Imx3duc : 
        case NPIC_PAN_Imx3dsl : 
        case NPIC_PAN_Imx3dsf : 
        case NPIC_PAN4_Imx3dul: 
            info->nband = info->swap ? NPIC_BSWAP32(attr[0]) : attr[0]; 
            info->ndep  = info->swap ? NPIC_BSWAP32(attr[1]) : attr[1]; 
            info->nrow  = info->swap ? NPIC_BSWAP32(attr[2]) : attr[2]; 
            info->ncol  = info->swap ? NPIC_BSWAP32(attr[3]) : attr[3]; 
            break;
        default : return NPIC_ERR_UNEX_TYPE;
    }
    
    /* Get npic_type and npic_dim */
    switch (info->potype) {
        case NPIC_PAN_Img2duc : 
            info->npic_type = NPIC_IMAGE_2C; info->npic_dim = 2; break;
        case NPIC_PAN_Img2dsl : 
            info->npic_type = NPIC_IMAGE_2L; info->npic_dim = 2; break;
        case NPIC_PAN_Img2dsf : 
            info->npic_type = NPIC_IMAGE_2D; info->npic_dim = 2; break;
        case NPIC_PAN4_Imx2dul: 
            info->npic_type = NPIC_IMAGE_2Q; info->npic_dim = 2; break;
        case NPIC_PAN4_Imx3dul: 
            info->npic_type = NPIC_IMAGE_3Q; info->npic_dim = 3; break;

        case NPIC_PAN_Img3duc : 
        case NPIC_PAN_Imx3duc : 
            if (info->nband == 1)
                 { info->npic_type = NPIC_IMAGE_3C; info->npic_dim = 3; }
            else { info->npic_type = NPIC_IMAGE_4C; info->npic_dim = 4; }
            break;
        case NPIC_PAN_Img3dsl :
        case NPIC_PAN_Imx3dsl :
            if (info->nband == 1)
                 { info->npic_type = NPIC_IMAGE_3L; info->npic_dim = 3; }
            else { info->npic_type = NPIC_IMAGE_4L; info->npic_dim = 4; }
            break;
        case NPIC_PAN_Img3dsf : 
        case NPIC_PAN_Imx3dsf : 
            if (info->nband == 1)
                 { info->npic_type = NPIC_IMAGE_3D; info->npic_dim = 3; }
            else { info->npic_type = NPIC_IMAGE_4D; info->npic_dim = 4; }
            break;
        default : return NPIC_ERR_UNEX_TYPE;
    }
    
    /* Some more tests */
    switch (info->npic_type) {
        case NPIC_IMAGE_2Q :
        case NPIC_IMAGE_3Q :
            if (info->nband < 3 || info->nband > 4) return NPIC_ERR_BAND_NB;
            break;
    }

    return NPIC_SUCCESS;
}


/*
 * Read binary datas from f1.
 *
 * Return NPIC_SUCCESS, else error code. Silent.
*/

int NpicPANReadDatas (Npic_image *np, FILE *f1, int swap)
{
    if (np == NULL) return NPIC_ERR_NULL_PTR;
    if (f1 == NULL) return NPIC_ERR_BAD_FD;
    
    switch (np->type) {

        case NPIC_IMAGE_2D : {
            int x, y, j, k;
            float  h, buf[FBUF_FLOAT];
            Npic_image_2d *I = NpicCastImage(np);
            union { float f; Npic_sint32 i; } u;

            j = k = 0;
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                if (j == k) {
                    j = 0;
                    k = fread (buf, sizeof(h), FBUF_FLOAT, f1);
                    if (k <= 0) return NPIC_ERR_READ;
                }
                u.f = buf[j];
                if (swap) u.i = NPIC_BSWAP32(u.i); 
                I->pix[y][x] = u.f;
                j++;
            }
        } break;

        case NPIC_IMAGE_3D : {
            int x, y, z, j, k;
            float  h, buf[FBUF_FLOAT];
            Npic_image_3d *I = NpicCastImage(np);
            union { float f; Npic_sint32 i; } u;

            j = k = 0;
            for (z = 0; z < I->zmax; z++)
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                if (j == k) {
                    j = 0;
                    k = fread (buf, sizeof(h), FBUF_FLOAT, f1);
                    if (k <= 0) return NPIC_ERR_READ;
                }
                u.f = buf[j];
                if (swap) u.i = NPIC_BSWAP32(u.i); 
                I->pix[z][y][x] = u.f;
                j++;
            }
        } break;

        case NPIC_IMAGE_4D : {
            int x, y, z, t, j, k;
            float  h, buf[FBUF_FLOAT];
            Npic_image_4d *I = NpicCastImage(np);
            union { float f; Npic_sint32 i; } u;

            j = k = 0;
            for (t = 0; t < I->tmax; t++)
            for (z = 0; z < I->zmax; z++)
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                if (j == k) {
                    j = 0;
                    k = fread (buf, sizeof(h), FBUF_FLOAT, f1);
                    if (k <= 0) return NPIC_ERR_READ;
                }
                u.f = buf[j];
                if (swap) u.i = NPIC_BSWAP32(u.i); 
                I->pix[t][z][y][x] = u.f;
                j++;
            }
        } break;

        case NPIC_IMAGE_2Q : {  /* NPIC_PAN4_Imx2dul */
            int y, x, j, k, swap = 0;
            Npic_l  h, buf[FBUF_INT32];
            Npic_image_2q *I = NpicCastImage(np);

            j = k = 0;
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                if (j == k) {
                    j = 0;
                    k = fread (buf, sizeof(h), FBUF_INT32, f1);
                    if (k <= 0) return NPIC_ERR_READ;
                }
                h = swap ? NPIC_BSWAP32(buf[j]) : buf[j];
                I->pix[y][x].a = h >> 16;
                j++;
            }
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                if (j == k) {
                    j = 0;
                    k = fread (buf, sizeof(h), FBUF_INT32, f1);
                    if (k <= 0) return NPIC_ERR_READ;
                }
                h = swap ? NPIC_BSWAP32(buf[j]) : buf[j];
                I->pix[y][x].b = h >> 16;
                j++;
            }
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                if (j == k) {
                    j = 0;
                    k = fread (buf, sizeof(h), FBUF_INT32, f1);
                    if (k <= 0) return NPIC_ERR_READ;
                }
                h = swap ? NPIC_BSWAP32(buf[j]) : buf[j];
                I->pix[y][x].c = h >> 16;
                j++;
            }
            if (feof(f1) && j == k) break;  /* no alpha channel */
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                if (j == k) {
                    j = 0;
                    k = fread (buf, sizeof(h), FBUF_INT32, f1);
                    if (k <= 0) return NPIC_ERR_READ;
                }
                h = swap ? NPIC_BSWAP32(buf[j]) : buf[j];
                I->pix[y][x].d = h >> 16;
                j++;
            }
        } break;

        case NPIC_IMAGE_3Q : {  /* NPIC_PAN4_Imx3dul */
            int z, y, x, j, k, swap = 0;
            Npic_l  h, buf[FBUF_INT32];
            Npic_image_3q *I = NpicCastImage(np);

            j = k = 0;
            for (z = 0; z < I->zmax; z++)
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                if (j == k) {
                    j = 0;
                    k = fread (buf, sizeof(h), FBUF_INT32, f1);
                    if (k <= 0) return NPIC_ERR_READ;
                }
                h = swap ? NPIC_BSWAP32(buf[j]) : buf[j];
                I->pix[z][y][x].a = h >> 16;
                j++;
            }
            for (z = 0; z < I->zmax; z++)
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                if (j == k) {
                    j = 0;
                    k = fread (buf, sizeof(h), FBUF_INT32, f1);
                    if (k <= 0) return NPIC_ERR_READ;
                }
                h = swap ? NPIC_BSWAP32(buf[j]) : buf[j];
                I->pix[z][y][x].b = h >> 16;
                j++;
            }
            for (z = 0; z < I->zmax; z++)
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                if (j == k) {
                    j = 0;
                    k = fread (buf, sizeof(h), FBUF_INT32, f1);
                    if (k <= 0) return NPIC_ERR_READ;
                }
                h = swap ? NPIC_BSWAP32(buf[j]) : buf[j];
                I->pix[z][y][x].c = h >> 16;
                j++;
            }
            if (feof(f1) && j == k) break;  /* no alpha channel */
            for (z = 0; z < I->zmax; z++)
            for (y = 0; y < I->ymax; y++)
            for (x = 0; x < I->xmax; x++)
            {
                if (j == k) {
                    j = 0;
                    k = fread (buf, sizeof(h), FBUF_INT32, f1);
                    if (k <= 0) return NPIC_ERR_READ;
                }
                h = swap ? NPIC_BSWAP32(buf[j]) : buf[j];
                I->pix[z][y][x].d = h >> 16;
                j++;
            }
        } break;

        default : return NpicReadRAW (np, f1, swap);
    }
   
    return NPIC_SUCCESS;
}


/*
 * Print infos on file.
 * Return NPIC_SUCCESS, else error code. Verbose.
*/

int NpicPANPrintInfo (const char *filename, Npic_pan_info *info)
{
    printf ("FILENAME \"%s\"\n", filename);
    
    if (info == NULL) return NPIC_ERR_NULL_PTR;
    printf ("MAGIC    %s\n", info->magic);
    printf ("POTYPE   %s\n", NpicPANPotypeName(info->potype));
    printf ("IDENT    %s\n", info->ident);
    printf ("DATE     2%s\n", info->date);
    printf ("NBAND    %d\n", info->nband);
    printf ("NDEP     %d\n", info->ndep);
    printf ("NROW     %d\n", info->nrow);
    printf ("NCOL     %d\n", info->ncol);
    printf ("SWAP     %s\n", info->swap ? "yes" : "no");
    printf ("TYPE     %s\n", NpicImageTypeName(info->npic_type));
    printf ("DIM      %d\n", info->npic_dim);
    printf ("XMAX     %d\n", info->ncol);
    printf ("YMAX     %d\n", info->nrow);
    if (info->npic_dim >= 3) printf ("ZMAX     %d\n", info->ndep);
    if (info->npic_dim >= 4) printf ("TMAX     %d\n", info->nband);
    
    return NPIC_SUCCESS;
}


/*
 * Return potype name from potype.
*/

const char *NpicPANPotypeName (Npic_sint32 potype)
{
    switch (potype) {
        case NPIC_PAN_Unknown :     return "Po_Unknown";
        case NPIC_PAN_Collection :  return "Po_Collection";
        case NPIC_PAN_Img1duc :     return "Po_Img1duc";
        case NPIC_PAN_Img1dsl :     return "Po_Img1dsl";
        case NPIC_PAN_Img1dsf :     return "Po_Img1dsf";
        case NPIC_PAN_Img2duc :     return "Po_Img2duc";
        case NPIC_PAN_Img2dsl :     return "Po_Img2dsl";
        case NPIC_PAN_Img2dsf :     return "Po_Img2dsf";
        case NPIC_PAN_Img3duc :     return "Po_Img3duc";
        case NPIC_PAN_Img3dsl :     return "Po_Img3dsl";
        case NPIC_PAN_Img3dsf :     return "Po_Img3dsf";
        case NPIC_PAN_Reg1d :       return "Po_Reg1d";
        case NPIC_PAN_Reg2d :       return "Po_Reg2d";
        case NPIC_PAN_Reg3d :       return "Po_Reg3d";
        case NPIC_PAN_Graph2d :     return "Po_Graph2d";
        case NPIC_PAN_Graph3d :     return "Po_Graph3d";
        case NPIC_PAN_Imc2duc :     return "Po_Imc2duc";
        case NPIC_PAN_Imc2dsl :     return "Po_Imc2dsl";
        case NPIC_PAN_Imc2dsf :     return "Po_Imc2dsf";
        case NPIC_PAN_Imc3duc :     return "Po_Imc3duc";
        case NPIC_PAN_Imc3dsl :     return "Po_Imc3dsl";
        case NPIC_PAN_Imc3dsf :     return "Po_Imc3dsf";
        case NPIC_PAN_Imx1duc :     return "Po_Imx1duc";
        case NPIC_PAN_Imx1dsl :     return "Po_Imx1dsl";
        case NPIC_PAN4_Imx1dul :    return "Po4_Imx1dul";
        case NPIC_PAN_Imx1dsf :     return "Po_Imx1dsf";
        case NPIC_PAN_Imx2duc :     return "Po_Imx2duc";
        case NPIC_PAN_Imx2dsl :     return "Po_Imx2dsl";
        case NPIC_PAN4_Imx2dul :    return "Po4_Imx2dul";
        case NPIC_PAN_Imx2dsf :     return "Po_Imx2dsf";
        case NPIC_PAN_Imx3duc :     return "Po_Imx3duc";
        case NPIC_PAN_Imx3dsl :     return "Po_Imx3dsl";
        case NPIC_PAN4_Imx3dul :    return "Po4_Imx3dul";
        case NPIC_PAN_Imx3dsf :     return "Po_Imx3dsf";
        case NPIC_PAN_Point1d :     return "Po_Point1d";
        case NPIC_PAN_Point2d :     return "Po_Point2d";
        case NPIC_PAN_Point3d :     return "Po_Point3d";
        case NPIC_PAN_Dimension1d : return "Po_Dimension1d";
        case NPIC_PAN_Dimension2d : return "Po_Dimension2d";
        case NPIC_PAN_Dimension3d : return "Po_Dimension3d";
        default :                   return "ERROR";
    }
}