/*
 * 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 "image_copy.ct" */

/*
 * image_copy.c - 12/01/2004
 *
 * Copy operations
*/


#include <npic.h>


/*----------------------------------------------------------------------------*/

/*
 * Copy operation ":="
 *
 * Set each pixel value of dest to the corresponding pixel value in src.
 * Do not copy nor modify border pixels.
 *
 * Do nothing if dest or src is not ok. set not ok for dest on error. Verbose.
 * 
 * The two images must have same dimension and size. To create the dest image,
 * you can use NpicCreateImage_??, NpicDupImage or NpicDupImageB.
 *
 * This function is usefull for conversion between 2 different images types.
 * Values can be truncated during conversion; no warning is done.
 *
 * USAGE:
 *    Npic_image *src, *dest;
 *
 *    src = NpicReadNPZ ("file.npz");
 *    ...
 *    dest = NpicDupImage (src);
 *    NpicCopyImageI (dest, src);
*/

void NpicCopyImageI (Npic_image *dest, Npic_image *src)
{
    if (NpicImageIsOK_DS1 (dest, src, __func__) != NPIC_SUCCESS)
        return;
        
    if (NpicSameImage (dest, src, NPIC_DIM | NPIC_SIZE) != NPIC_SUCCESS) {
        dest->gen.ok = NpicError (__func__, NPIC_ERR_INCOMPAT, ""); 
        return; 
    }
    
    switch (src->type)
    {
        case NPIC_IMAGE_2C :  /*-----------------------------------------------*/
        {
            Npic_image_2c *p1 = NpicCastImage (src);
            int x, y;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_2C :
                {
                    Npic_image_2c *p2 = NpicCastImage (dest);
        
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[y][x] = p1->pix[y][x];
        
                    return;
                }

                case NPIC_IMAGE_2L :
                {
                    Npic_image_2l *p2 = NpicCastImage (dest);
        
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[y][x] = p1->pix[y][x];
        
                    return;
                }

                case NPIC_IMAGE_2D :
                {
                    Npic_image_2d *p2 = NpicCastImage (dest);
        
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[y][x] = p1->pix[y][x];
        
                    return;
                }

                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_2L :  /*-----------------------------------------------*/
        {
            Npic_image_2l *p1 = NpicCastImage (src);
            int x, y;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_2C :
                {
                    Npic_image_2c *p2 = NpicCastImage (dest);
        
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[y][x] = p1->pix[y][x];
        
                    return;
                }

                case NPIC_IMAGE_2L :
                {
                    Npic_image_2l *p2 = NpicCastImage (dest);
        
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[y][x] = p1->pix[y][x];
        
                    return;
                }

                case NPIC_IMAGE_2D :
                {
                    Npic_image_2d *p2 = NpicCastImage (dest);
        
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[y][x] = p1->pix[y][x];
        
                    return;
                }

                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_2D :  /*-----------------------------------------------*/
        {
            Npic_image_2d *p1 = NpicCastImage (src);
            int x, y;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_2C :
                {
                    Npic_image_2c *p2 = NpicCastImage (dest);
        
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[y][x] = p1->pix[y][x];
        
                    return;
                }

                case NPIC_IMAGE_2L :
                {
                    Npic_image_2l *p2 = NpicCastImage (dest);
        
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[y][x] = p1->pix[y][x];
        
                    return;
                }

                case NPIC_IMAGE_2D :
                {
                    Npic_image_2d *p2 = NpicCastImage (dest);
        
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[y][x] = p1->pix[y][x];
        
                    return;
                }

                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_3C :  /*-----------------------------------------------*/
        {
            Npic_image_3c *p1 = NpicCastImage (src);
            int x, y, z;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_3C :
                {
                    Npic_image_3c *p2 = NpicCastImage (dest);
        
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[z][y][x] = p1->pix[z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_3L :
                {
                    Npic_image_3l *p2 = NpicCastImage (dest);
        
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[z][y][x] = p1->pix[z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_3D :
                {
                    Npic_image_3d *p2 = NpicCastImage (dest);
        
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[z][y][x] = p1->pix[z][y][x];
        
                    return;
                }

                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_3L :  /*-----------------------------------------------*/
        {
            Npic_image_3l *p1 = NpicCastImage (src);
            int x, y, z;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_3C :
                {
                    Npic_image_3c *p2 = NpicCastImage (dest);
        
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[z][y][x] = p1->pix[z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_3L :
                {
                    Npic_image_3l *p2 = NpicCastImage (dest);
        
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[z][y][x] = p1->pix[z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_3D :
                {
                    Npic_image_3d *p2 = NpicCastImage (dest);
        
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[z][y][x] = p1->pix[z][y][x];
        
                    return;
                }

                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_3D :  /*-----------------------------------------------*/
        {
            Npic_image_3d *p1 = NpicCastImage (src);
            int x, y, z;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_3C :
                {
                    Npic_image_3c *p2 = NpicCastImage (dest);
        
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[z][y][x] = p1->pix[z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_3L :
                {
                    Npic_image_3l *p2 = NpicCastImage (dest);
        
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[z][y][x] = p1->pix[z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_3D :
                {
                    Npic_image_3d *p2 = NpicCastImage (dest);
        
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[z][y][x] = p1->pix[z][y][x];
        
                    return;
                }

                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_4C :  /*-----------------------------------------------*/
        {
            Npic_image_4c *p1 = NpicCastImage (src);
            int x, y, z, t;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_4C :
                {
                    Npic_image_4c *p2 = NpicCastImage (dest);
        
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[t][z][y][x] = p1->pix[t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_4L :
                {
                    Npic_image_4l *p2 = NpicCastImage (dest);
        
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[t][z][y][x] = p1->pix[t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_4D :
                {
                    Npic_image_4d *p2 = NpicCastImage (dest);
        
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[t][z][y][x] = p1->pix[t][z][y][x];
        
                    return;
                }

                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_4L :  /*-----------------------------------------------*/
        {
            Npic_image_4l *p1 = NpicCastImage (src);
            int x, y, z, t;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_4C :
                {
                    Npic_image_4c *p2 = NpicCastImage (dest);
        
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[t][z][y][x] = p1->pix[t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_4L :
                {
                    Npic_image_4l *p2 = NpicCastImage (dest);
        
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[t][z][y][x] = p1->pix[t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_4D :
                {
                    Npic_image_4d *p2 = NpicCastImage (dest);
        
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[t][z][y][x] = p1->pix[t][z][y][x];
        
                    return;
                }

                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_4D :  /*-----------------------------------------------*/
        {
            Npic_image_4d *p1 = NpicCastImage (src);
            int x, y, z, t;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_4C :
                {
                    Npic_image_4c *p2 = NpicCastImage (dest);
        
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[t][z][y][x] = p1->pix[t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_4L :
                {
                    Npic_image_4l *p2 = NpicCastImage (dest);
        
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[t][z][y][x] = p1->pix[t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_4D :
                {
                    Npic_image_4d *p2 = NpicCastImage (dest);
        
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[t][z][y][x] = p1->pix[t][z][y][x];
        
                    return;
                }

                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_5C :  /*-----------------------------------------------*/
        {
            Npic_image_5c *p1 = NpicCastImage (src);
            int x, y, z, t, s;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_5C :
                {
                    Npic_image_5c *p2 = NpicCastImage (dest);
        
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[s][t][z][y][x] = p1->pix[s][t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_5L :
                {
                    Npic_image_5l *p2 = NpicCastImage (dest);
        
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[s][t][z][y][x] = p1->pix[s][t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_5D :
                {
                    Npic_image_5d *p2 = NpicCastImage (dest);
        
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[s][t][z][y][x] = p1->pix[s][t][z][y][x];
        
                    return;
                }

                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_5L :  /*-----------------------------------------------*/
        {
            Npic_image_5l *p1 = NpicCastImage (src);
            int x, y, z, t, s;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_5C :
                {
                    Npic_image_5c *p2 = NpicCastImage (dest);
        
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[s][t][z][y][x] = p1->pix[s][t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_5L :
                {
                    Npic_image_5l *p2 = NpicCastImage (dest);
        
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[s][t][z][y][x] = p1->pix[s][t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_5D :
                {
                    Npic_image_5d *p2 = NpicCastImage (dest);
        
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[s][t][z][y][x] = p1->pix[s][t][z][y][x];
        
                    return;
                }

                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_5D :  /*-----------------------------------------------*/
        {
            Npic_image_5d *p1 = NpicCastImage (src);
            int x, y, z, t, s;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_5C :
                {
                    Npic_image_5c *p2 = NpicCastImage (dest);
        
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[s][t][z][y][x] = p1->pix[s][t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_5L :
                {
                    Npic_image_5l *p2 = NpicCastImage (dest);
        
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[s][t][z][y][x] = p1->pix[s][t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_5D :
                {
                    Npic_image_5d *p2 = NpicCastImage (dest);
        
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[s][t][z][y][x] = p1->pix[s][t][z][y][x];
        
                    return;
                }

                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_6C :  /*-----------------------------------------------*/
        {
            Npic_image_6c *p1 = NpicCastImage (src);
            int x, y, z, t, s, r;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_6C :
                {
                    Npic_image_6c *p2 = NpicCastImage (dest);
        
                    for (r = 0; r < p1->rmax; r++)
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[r][s][t][z][y][x] = p1->pix[r][s][t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_6L :
                {
                    Npic_image_6l *p2 = NpicCastImage (dest);
        
                    for (r = 0; r < p1->rmax; r++)
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[r][s][t][z][y][x] = p1->pix[r][s][t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_6D :
                {
                    Npic_image_6d *p2 = NpicCastImage (dest);
        
                    for (r = 0; r < p1->rmax; r++)
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[r][s][t][z][y][x] = p1->pix[r][s][t][z][y][x];
        
                    return;
                }

                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_6L :  /*-----------------------------------------------*/
        {
            Npic_image_6l *p1 = NpicCastImage (src);
            int x, y, z, t, s, r;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_6C :
                {
                    Npic_image_6c *p2 = NpicCastImage (dest);
        
                    for (r = 0; r < p1->rmax; r++)
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[r][s][t][z][y][x] = p1->pix[r][s][t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_6L :
                {
                    Npic_image_6l *p2 = NpicCastImage (dest);
        
                    for (r = 0; r < p1->rmax; r++)
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[r][s][t][z][y][x] = p1->pix[r][s][t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_6D :
                {
                    Npic_image_6d *p2 = NpicCastImage (dest);
        
                    for (r = 0; r < p1->rmax; r++)
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[r][s][t][z][y][x] = p1->pix[r][s][t][z][y][x];
        
                    return;
                }

                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_6D :  /*-----------------------------------------------*/
        {
            Npic_image_6d *p1 = NpicCastImage (src);
            int x, y, z, t, s, r;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_6C :
                {
                    Npic_image_6c *p2 = NpicCastImage (dest);
        
                    for (r = 0; r < p1->rmax; r++)
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[r][s][t][z][y][x] = p1->pix[r][s][t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_6L :
                {
                    Npic_image_6l *p2 = NpicCastImage (dest);
        
                    for (r = 0; r < p1->rmax; r++)
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[r][s][t][z][y][x] = p1->pix[r][s][t][z][y][x];
        
                    return;
                }

                case NPIC_IMAGE_6D :
                {
                    Npic_image_6d *p2 = NpicCastImage (dest);
        
                    for (r = 0; r < p1->rmax; r++)
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[r][s][t][z][y][x] = p1->pix[r][s][t][z][y][x];
        
                    return;
                }

                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }

        case NPIC_IMAGE_2Q :  /*-----------------------------------------------*/
        {
            Npic_image_2q *p1 = NpicCastImage (src);
            int y, x;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_2Q :
                {
                    Npic_image_2q *p2 = NpicCastImage (dest);
        
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[y][x] = p1->pix[y][x];
        
                    return;
                }
                    
                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_3Q :  /*-----------------------------------------------*/
        {
            Npic_image_3q *p1 = NpicCastImage (src);
            int z, y, x;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_3Q :
                {
                    Npic_image_3q *p2 = NpicCastImage (dest);
        
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[z][y][x] = p1->pix[z][y][x];
        
                    return;
                }
                    
                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_4Q :  /*-----------------------------------------------*/
        {
            Npic_image_4q *p1 = NpicCastImage (src);
            int t, z, y, x;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_4Q :
                {
                    Npic_image_4q *p2 = NpicCastImage (dest);
        
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[t][z][y][x] = p1->pix[t][z][y][x];
        
                    return;
                }
                    
                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_5Q :  /*-----------------------------------------------*/
        {
            Npic_image_5q *p1 = NpicCastImage (src);
            int s, t, z, y, x;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_5Q :
                {
                    Npic_image_5q *p2 = NpicCastImage (dest);
        
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[s][t][z][y][x] = p1->pix[s][t][z][y][x];
        
                    return;
                }
                    
                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        case NPIC_IMAGE_6Q :  /*-----------------------------------------------*/
        {
            Npic_image_6q *p1 = NpicCastImage (src);
            int r, s, t, z, y, x;
        
            switch (dest->type)
            {
                case NPIC_IMAGE_6Q :
                {
                    Npic_image_6q *p2 = NpicCastImage (dest);
        
                    for (r = 0; r < p1->rmax; r++)
                    for (s = 0; s < p1->smax; s++)
                    for (t = 0; t < p1->tmax; t++)
                    for (z = 0; z < p1->zmax; z++)
                    for (y = 0; y < p1->ymax; y++)
                    for (x = 0; x < p1->xmax; x++)
                        p2->pix[r][s][t][z][y][x] = p1->pix[r][s][t][z][y][x];
        
                    return;
                }
                    
                default : 
                    dest->gen.ok = NpicError (__func__, NPIC_ERR_BAD_CONV, ""); 
                    return;
            }
        }
        
        default :       /*-----------------------------------------------*/
            dest->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, ""); 
            return;
    }
}


/*
 * Copy pixels from src to dest, including border pixels.
 * The two images have same type, size and border.
 *
 * Do nothing if dest or src is not ok. set not ok for dest on error. Verbose.
*/

void NpicCopyImageIB (Npic_image *dest, Npic_image *src)
{
    if (NpicImageIsOK_DS1 (dest, src, __func__) != NPIC_SUCCESS)
        return;
        
    if (NpicSameImage (dest, src, NPIC_TYPE | NPIC_SIZE | NPIC_BORD) != NPIC_SUCCESS) {
        dest->gen.ok = NpicError (__func__, NPIC_ERR_INCOMPAT, ""); 
        return; 
    }

    memcpy (dest->gen.vec_, src->gen.vec_, src->gen.pixtot * src->gen.pixsize);
}


/*
 * Copy border pixels from src to dest.
 * Do not modify image pixels.
 *
 * The two images have same type, size and border.
 *
 * Do nothing if dest or src is not ok. set not ok for dest on error. Verbose.
*/

void NpicCopyImageB (Npic_image *dest, Npic_image *src)
{
    Npic_image *tmp;
    
    if (NpicImageIsOK_DS1 (dest, src, __func__) != NPIC_SUCCESS)
        return;
        
    if (NpicSameImage (dest, src, NPIC_TYPE | NPIC_SIZE | NPIC_BORD) != NPIC_SUCCESS) {
        dest->gen.ok = NpicError (__func__, NPIC_ERR_INCOMPAT, ""); 
        return; 
    }

    tmp = NpicDupImage (dest);
    if (tmp == NULL) { dest->gen.ok = NPIC_ERROR; return; }
    
    NpicCopyImageIB (tmp, src);
    NpicCopyImageI (tmp, dest);
    NpicSwapImage (tmp, dest);
    NpicDestroyImage (tmp);
}


/*----------------------------------------------------------------------------*/

/*
 * Convert image pixels to Npic_c format (border pixels excluded). 
 * Values can be truncated during conversion; no warning is done.
 *
 * Do nothing if np is not ok. set not ok for np on error. Verbose.
 *
 * USAGE:
 *    Npic_image *np;
 *
 *    np = NpicReadNPZ ("file.npz");
 *    ...
 *    NpicConvertImage_c (np);
*/

void NpicConvertImage_c (Npic_image *np1)
{
    Npic_image *np2;

    if (NpicImageIsOK (np1, __func__) != NPIC_SUCCESS) return;
    
    switch (np1->type) {
        case NPIC_IMAGE_2C: 
        case NPIC_IMAGE_3C: 
        case NPIC_IMAGE_4C: 
        case NPIC_IMAGE_5C: 
        case NPIC_IMAGE_6C: 
            return;  /* Already in Npic_c format */

        case NPIC_IMAGE_2L: 
        case NPIC_IMAGE_2D: 
            np2 = NpicCreateImage_2c (
                np1->gen.ymax, np1->gen.xmax, 
                0, 0);
            break;

        case NPIC_IMAGE_3L: 
        case NPIC_IMAGE_3D: 
            np2 = NpicCreateImage_3c (
                np1->gen.zmax, np1->gen.ymax, np1->gen.xmax, 
                0, 0, 0);
            break;

        case NPIC_IMAGE_4L: 
        case NPIC_IMAGE_4D: 
            np2 = NpicCreateImage_4c (
                np1->gen.tmax, 
                np1->gen.zmax, np1->gen.ymax, np1->gen.xmax, 
                0, 0, 0, 0);
            break;

        case NPIC_IMAGE_5L: 
        case NPIC_IMAGE_5D: 
            np2 = NpicCreateImage_5c (
                np1->gen.smax, np1->gen.tmax, 
                np1->gen.zmax, np1->gen.ymax, np1->gen.xmax, 
                0, 0, 0, 0, 0);
            break;

        case NPIC_IMAGE_6L: 
        case NPIC_IMAGE_6D: 
            np2 = NpicCreateImage_6c (
                np1->gen.rmax, np1->gen.smax, np1->gen.tmax, 
                np1->gen.zmax, np1->gen.ymax, np1->gen.xmax, 
                0, 0, 0, 0, 0, 0);
            break;

        default :
            np1->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
            return;
    }

    NpicCopyImageI (np2, np1);
    NpicSwapImage (np2, np1);
    NpicDestroyImage (np2);
}


/*
 * Convert image pixels to Npic_l format (border pixels excluded). 
 * Values can be truncated during conversion; no warning is done.
 *
 * Do nothing if np is not ok. set not ok for np on error. Verbose.
 *
 * USAGE:
 *    Npic_image *np;
 *
 *    np = NpicReadNPZ ("file.npz");
 *    ...
 *    NpicConvertImage_l (np);
*/

void NpicConvertImage_l (Npic_image *np1)
{
    Npic_image *np2;

    if (NpicImageIsOK (np1, __func__) != NPIC_SUCCESS) return;
    
    switch (np1->type) {
        case NPIC_IMAGE_2L: 
        case NPIC_IMAGE_3L: 
        case NPIC_IMAGE_4L: 
        case NPIC_IMAGE_5L: 
        case NPIC_IMAGE_6L: 
            return;  /* Already in Npic_l format */

        case NPIC_IMAGE_2C: 
        case NPIC_IMAGE_2D: 
            np2 = NpicCreateImage_2l (
                np1->gen.ymax, np1->gen.xmax, 
                0, 0);
            break;

        case NPIC_IMAGE_3C: 
        case NPIC_IMAGE_3D: 
            np2 = NpicCreateImage_3l (
                np1->gen.zmax, np1->gen.ymax, np1->gen.xmax, 
                0, 0, 0);
            break;

        case NPIC_IMAGE_4C: 
        case NPIC_IMAGE_4D: 
            np2 = NpicCreateImage_4l (
                np1->gen.tmax, 
                np1->gen.zmax, np1->gen.ymax, np1->gen.xmax, 
                0, 0, 0, 0);
            break;

        case NPIC_IMAGE_5C: 
        case NPIC_IMAGE_5D: 
            np2 = NpicCreateImage_5l (
                np1->gen.smax, np1->gen.tmax, 
                np1->gen.zmax, np1->gen.ymax, np1->gen.xmax, 
                0, 0, 0, 0, 0);
            break;

        case NPIC_IMAGE_6C: 
        case NPIC_IMAGE_6D: 
            np2 = NpicCreateImage_6l (
                np1->gen.rmax, np1->gen.smax, np1->gen.tmax, 
                np1->gen.zmax, np1->gen.ymax, np1->gen.xmax, 
                0, 0, 0, 0, 0, 0);
            break;

        default :
            np1->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
            return;
    }

    NpicCopyImageI (np2, np1);
    NpicSwapImage (np2, np1);
    NpicDestroyImage (np2);
}


/*
 * Convert image pixels to Npic_d format (border pixels excluded).
 * Values can be truncated during conversion; no warning is done.
 *
 * Do nothing if np is not ok. set not ok for np on error. Verbose.
 *
 * USAGE:
 *    Npic_image *np;
 *
 *    np = NpicReadNPZ ("file.npz");
 *    ...
 *    NpicConvertImage_d (np);
*/

void NpicConvertImage_d (Npic_image *np1)
{
    Npic_image *np2;

    if (NpicImageIsOK (np1, __func__) != NPIC_SUCCESS) return;
    
    switch (np1->type) {
        case NPIC_IMAGE_2D: 
        case NPIC_IMAGE_3D: 
        case NPIC_IMAGE_4D: 
        case NPIC_IMAGE_5D: 
        case NPIC_IMAGE_6D: 
            return;  /* Already in Npic_d format */

        case NPIC_IMAGE_2C: 
        case NPIC_IMAGE_2L: 
            np2 = NpicCreateImage_2d (
                np1->gen.ymax, np1->gen.xmax, 
                0, 0);
            break;

        case NPIC_IMAGE_3C: 
        case NPIC_IMAGE_3L: 
            np2 = NpicCreateImage_3d (
                np1->gen.zmax, np1->gen.ymax, np1->gen.xmax, 
                0, 0, 0);
            break;

        case NPIC_IMAGE_4C: 
        case NPIC_IMAGE_4L: 
            np2 = NpicCreateImage_4d (
                np1->gen.tmax, 
                np1->gen.zmax, np1->gen.ymax, np1->gen.xmax, 
                0, 0, 0, 0);
            break;

        case NPIC_IMAGE_5C: 
        case NPIC_IMAGE_5L: 
            np2 = NpicCreateImage_5d (
                np1->gen.smax, np1->gen.tmax, 
                np1->gen.zmax, np1->gen.ymax, np1->gen.xmax, 
                0, 0, 0, 0, 0);
            break;

        case NPIC_IMAGE_6C: 
        case NPIC_IMAGE_6L: 
            np2 = NpicCreateImage_6d (
                np1->gen.rmax, np1->gen.smax, np1->gen.tmax, 
                np1->gen.zmax, np1->gen.ymax, np1->gen.xmax, 
                0, 0, 0, 0, 0, 0);
            break;

        default :
            np1->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
            return;
    }

    NpicCopyImageI (np2, np1);
    NpicSwapImage (np2, np1);
    NpicDestroyImage (np2);
}

/*----------------------------------------------------------------------------*/