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

/*
 * image_slice.c - 13/11/2008
 *
 * Get a slice of an image.
*/


#include <npic.h>


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

/*
 * Create an image of dimension-1, containing the slice for the coordinate.
 * Return new image or NULL.
*/

Npic_image *NpicCreateSlice_r (Npic_image *np1, int r)
{
    Npic_image *np2 = NULL;

    if (NpicImageIsOK (np1, __func__) != NPIC_SUCCESS) return NULL;

    switch (np1->type) {

        case NPIC_IMAGE_6C : {
            Npic_image_6c *p1 = NpicCastImage (np1);
            Npic_image_5c *p2;
            int s, t, z, y, x;

            if (r < 0 || r >= p1->rmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5c (
                p1->smax, p1->tmax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6L : {
            Npic_image_6l *p1 = NpicCastImage (np1);
            Npic_image_5l *p2;
            int s, t, z, y, x;

            if (r < 0 || r >= p1->rmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5l (
                p1->smax, p1->tmax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6D : {
            Npic_image_6d *p1 = NpicCastImage (np1);
            Npic_image_5d *p2;
            int s, t, z, y, x;

            if (r < 0 || r >= p1->rmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5d (
                p1->smax, p1->tmax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6Q : {
            Npic_image_6q *p1 = NpicCastImage (np1);
            Npic_image_5q *p2;
            int s, t, z, y, x;

            if (r < 0 || r >= p1->rmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5q (
                p1->smax, p1->tmax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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[r][s][t][z][y][x];
        } break;

        default :
            NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
            return NULL;
    }

    return np2;
}

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

Npic_image *NpicCreateSlice_s (Npic_image *np1, int s)
{
    Npic_image *np2 = NULL;

    if (NpicImageIsOK (np1, __func__) != NPIC_SUCCESS) return NULL;

    switch (np1->type) {

        case NPIC_IMAGE_5C : {
            Npic_image_5c *p1 = NpicCastImage (np1);
            Npic_image_4c *p2;
            int t, z, y, x;

            if (s < 0 || s >= p1->smax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4c (
                p1->tmax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_5L : {
            Npic_image_5l *p1 = NpicCastImage (np1);
            Npic_image_4l *p2;
            int t, z, y, x;

            if (s < 0 || s >= p1->smax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4l (
                p1->tmax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_5D : {
            Npic_image_5d *p1 = NpicCastImage (np1);
            Npic_image_4d *p2;
            int t, z, y, x;

            if (s < 0 || s >= p1->smax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4d (
                p1->tmax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_5Q : {
            Npic_image_5q *p1 = NpicCastImage (np1);
            Npic_image_4q *p2;
            int t, z, y, x;

            if (s < 0 || s >= p1->smax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4q (
                p1->tmax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6C : {
            Npic_image_6c *p1 = NpicCastImage (np1);
            Npic_image_5c *p2;
            int r, t, z, y, x;

            if (s < 0 || s >= p1->smax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5c (
                p1->rmax, p1->tmax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (r = 0; r < p1->rmax; r++)
            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][t][z][y][x] = p1->pix[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6L : {
            Npic_image_6l *p1 = NpicCastImage (np1);
            Npic_image_5l *p2;
            int r, t, z, y, x;

            if (s < 0 || s >= p1->smax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5l (
                p1->rmax, p1->tmax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (r = 0; r < p1->rmax; r++)
            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][t][z][y][x] = p1->pix[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6D : {
            Npic_image_6d *p1 = NpicCastImage (np1);
            Npic_image_5d *p2;
            int r, t, z, y, x;

            if (s < 0 || s >= p1->smax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5d (
                p1->rmax, p1->tmax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (r = 0; r < p1->rmax; r++)
            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][t][z][y][x] = p1->pix[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6Q : {
            Npic_image_6q *p1 = NpicCastImage (np1);
            Npic_image_5q *p2;
            int r, t, z, y, x;

            if (s < 0 || s >= p1->smax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5q (
                p1->rmax, p1->tmax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (r = 0; r < p1->rmax; r++)
            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][t][z][y][x] = p1->pix[r][s][t][z][y][x];
        } break;

        default :
            NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
            return NULL;
    }

    return np2;
}

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

Npic_image *NpicCreateSlice_t (Npic_image *np1, int t)
{
    Npic_image *np2 = NULL;

    if (NpicImageIsOK (np1, __func__) != NPIC_SUCCESS) return NULL;

    switch (np1->type) {

        case NPIC_IMAGE_4C : {
            Npic_image_4c *p1 = NpicCastImage (np1);
            Npic_image_3c *p2;
            int z, y, x;

            if (t < 0 || t >= p1->tmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_3c (
                p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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[t][z][y][x];
        } break;

        case NPIC_IMAGE_4L : {
            Npic_image_4l *p1 = NpicCastImage (np1);
            Npic_image_3l *p2;
            int z, y, x;

            if (t < 0 || t >= p1->tmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_3l (
                p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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[t][z][y][x];
        } break;

        case NPIC_IMAGE_4D : {
            Npic_image_4d *p1 = NpicCastImage (np1);
            Npic_image_3d *p2;
            int z, y, x;

            if (t < 0 || t >= p1->tmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_3d (
                p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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[t][z][y][x];
        } break;

        case NPIC_IMAGE_4Q : {
            Npic_image_4q *p1 = NpicCastImage (np1);
            Npic_image_3q *p2;
            int z, y, x;

            if (t < 0 || t >= p1->tmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_3q (
                p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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[t][z][y][x];
        } break;

        case NPIC_IMAGE_5C : {
            Npic_image_5c *p1 = NpicCastImage (np1);
            Npic_image_4c *p2;
            int s, z, y, x;

            if (t < 0 || t >= p1->tmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4c (
                p1->smax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (s = 0; s < p1->smax; s++)
            for (z = 0; z < p1->zmax; z++)
            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[s][z][y][x] = p1->pix[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_5L : {
            Npic_image_5l *p1 = NpicCastImage (np1);
            Npic_image_4l *p2;
            int s, z, y, x;

            if (t < 0 || t >= p1->tmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4l (
                p1->smax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (s = 0; s < p1->smax; s++)
            for (z = 0; z < p1->zmax; z++)
            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[s][z][y][x] = p1->pix[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_5D : {
            Npic_image_5d *p1 = NpicCastImage (np1);
            Npic_image_4d *p2;
            int s, z, y, x;

            if (t < 0 || t >= p1->tmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4d (
                p1->smax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (s = 0; s < p1->smax; s++)
            for (z = 0; z < p1->zmax; z++)
            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[s][z][y][x] = p1->pix[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_5Q : {
            Npic_image_5q *p1 = NpicCastImage (np1);
            Npic_image_4q *p2;
            int s, z, y, x;

            if (t < 0 || t >= p1->tmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4q (
                p1->smax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (s = 0; s < p1->smax; s++)
            for (z = 0; z < p1->zmax; z++)
            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[s][z][y][x] = p1->pix[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6C : {
            Npic_image_6c *p1 = NpicCastImage (np1);
            Npic_image_5c *p2;
            int r, s, z, y, x;

            if (t < 0 || t >= p1->tmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5c (
                p1->rmax, p1->smax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (r = 0; r < p1->rmax; r++)
            for (s = 0; s < p1->smax; s++)
            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][z][y][x] = p1->pix[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6L : {
            Npic_image_6l *p1 = NpicCastImage (np1);
            Npic_image_5l *p2;
            int r, s, z, y, x;

            if (t < 0 || t >= p1->tmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5l (
                p1->rmax, p1->smax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (r = 0; r < p1->rmax; r++)
            for (s = 0; s < p1->smax; s++)
            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][z][y][x] = p1->pix[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6D : {
            Npic_image_6d *p1 = NpicCastImage (np1);
            Npic_image_5d *p2;
            int r, s, z, y, x;

            if (t < 0 || t >= p1->tmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5d (
                p1->rmax, p1->smax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (r = 0; r < p1->rmax; r++)
            for (s = 0; s < p1->smax; s++)
            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][z][y][x] = p1->pix[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6Q : {
            Npic_image_6q *p1 = NpicCastImage (np1);
            Npic_image_5q *p2;
            int r, s, z, y, x;

            if (t < 0 || t >= p1->tmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5q (
                p1->rmax, p1->smax, p1->zmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (r = 0; r < p1->rmax; r++)
            for (s = 0; s < p1->smax; s++)
            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][z][y][x] = p1->pix[r][s][t][z][y][x];
        } break;

        default :
            NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
            return NULL;
    }

    return np2;
}

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

Npic_image *NpicCreateSlice_z (Npic_image *np1, int z)
{
    Npic_image *np2 = NULL;

    if (NpicImageIsOK (np1, __func__) != NPIC_SUCCESS) return NULL;

    switch (np1->type) {

        case NPIC_IMAGE_3C : {
            Npic_image_3c *p1 = NpicCastImage (np1);
            Npic_image_2c *p2;
            int y, x;

            if (z < 0 || z >= p1->zmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_2c (
                p1->ymax, p1->xmax, 
                0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[y][x] = p1->pix[z][y][x];
        } break;

        case NPIC_IMAGE_3L : {
            Npic_image_3l *p1 = NpicCastImage (np1);
            Npic_image_2l *p2;
            int y, x;

            if (z < 0 || z >= p1->zmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_2l (
                p1->ymax, p1->xmax, 
                0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[y][x] = p1->pix[z][y][x];
        } break;

        case NPIC_IMAGE_3D : {
            Npic_image_3d *p1 = NpicCastImage (np1);
            Npic_image_2d *p2;
            int y, x;

            if (z < 0 || z >= p1->zmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_2d (
                p1->ymax, p1->xmax, 
                0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[y][x] = p1->pix[z][y][x];
        } break;

        case NPIC_IMAGE_3Q : {
            Npic_image_3q *p1 = NpicCastImage (np1);
            Npic_image_2q *p2;
            int y, x;

            if (z < 0 || z >= p1->zmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_2q (
                p1->ymax, p1->xmax, 
                0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[y][x] = p1->pix[z][y][x];
        } break;

        case NPIC_IMAGE_4C : {
            Npic_image_4c *p1 = NpicCastImage (np1);
            Npic_image_3c *p2;
            int t, y, x;

            if (z < 0 || z >= p1->zmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_3c (
                p1->tmax, p1->ymax, p1->xmax, 
                0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (t = 0; t < p1->tmax; t++)
            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[t][y][x] = p1->pix[t][z][y][x];
        } break;

        case NPIC_IMAGE_4L : {
            Npic_image_4l *p1 = NpicCastImage (np1);
            Npic_image_3l *p2;
            int t, y, x;

            if (z < 0 || z >= p1->zmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_3l (
                p1->tmax, p1->ymax, p1->xmax, 
                0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (t = 0; t < p1->tmax; t++)
            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[t][y][x] = p1->pix[t][z][y][x];
        } break;

        case NPIC_IMAGE_4D : {
            Npic_image_4d *p1 = NpicCastImage (np1);
            Npic_image_3d *p2;
            int t, y, x;

            if (z < 0 || z >= p1->zmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_3d (
                p1->tmax, p1->ymax, p1->xmax, 
                0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (t = 0; t < p1->tmax; t++)
            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[t][y][x] = p1->pix[t][z][y][x];
        } break;

        case NPIC_IMAGE_4Q : {
            Npic_image_4q *p1 = NpicCastImage (np1);
            Npic_image_3q *p2;
            int t, y, x;

            if (z < 0 || z >= p1->zmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_3q (
                p1->tmax, p1->ymax, p1->xmax, 
                0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (t = 0; t < p1->tmax; t++)
            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[t][y][x] = p1->pix[t][z][y][x];
        } break;

        case NPIC_IMAGE_5C : {
            Npic_image_5c *p1 = NpicCastImage (np1);
            Npic_image_4c *p2;
            int s, t, y, x;

            if (z < 0 || z >= p1->zmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4c (
                p1->smax, p1->tmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (s = 0; s < p1->smax; s++)
            for (t = 0; t < p1->tmax; t++)
            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[s][t][y][x] = p1->pix[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_5L : {
            Npic_image_5l *p1 = NpicCastImage (np1);
            Npic_image_4l *p2;
            int s, t, y, x;

            if (z < 0 || z >= p1->zmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4l (
                p1->smax, p1->tmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (s = 0; s < p1->smax; s++)
            for (t = 0; t < p1->tmax; t++)
            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[s][t][y][x] = p1->pix[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_5D : {
            Npic_image_5d *p1 = NpicCastImage (np1);
            Npic_image_4d *p2;
            int s, t, y, x;

            if (z < 0 || z >= p1->zmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4d (
                p1->smax, p1->tmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (s = 0; s < p1->smax; s++)
            for (t = 0; t < p1->tmax; t++)
            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[s][t][y][x] = p1->pix[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_5Q : {
            Npic_image_5q *p1 = NpicCastImage (np1);
            Npic_image_4q *p2;
            int s, t, y, x;

            if (z < 0 || z >= p1->zmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4q (
                p1->smax, p1->tmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (s = 0; s < p1->smax; s++)
            for (t = 0; t < p1->tmax; t++)
            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[s][t][y][x] = p1->pix[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6C : {
            Npic_image_6c *p1 = NpicCastImage (np1);
            Npic_image_5c *p2;
            int r, s, t, y, x;

            if (z < 0 || z >= p1->zmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5c (
                p1->rmax, p1->smax, p1->tmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (r = 0; r < p1->rmax; r++)
            for (s = 0; s < p1->smax; s++)
            for (t = 0; t < p1->tmax; t++)
            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[r][s][t][y][x] = p1->pix[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6L : {
            Npic_image_6l *p1 = NpicCastImage (np1);
            Npic_image_5l *p2;
            int r, s, t, y, x;

            if (z < 0 || z >= p1->zmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5l (
                p1->rmax, p1->smax, p1->tmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (r = 0; r < p1->rmax; r++)
            for (s = 0; s < p1->smax; s++)
            for (t = 0; t < p1->tmax; t++)
            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[r][s][t][y][x] = p1->pix[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6D : {
            Npic_image_6d *p1 = NpicCastImage (np1);
            Npic_image_5d *p2;
            int r, s, t, y, x;

            if (z < 0 || z >= p1->zmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5d (
                p1->rmax, p1->smax, p1->tmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (r = 0; r < p1->rmax; r++)
            for (s = 0; s < p1->smax; s++)
            for (t = 0; t < p1->tmax; t++)
            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[r][s][t][y][x] = p1->pix[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6Q : {
            Npic_image_6q *p1 = NpicCastImage (np1);
            Npic_image_5q *p2;
            int r, s, t, y, x;

            if (z < 0 || z >= p1->zmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5q (
                p1->rmax, p1->smax, p1->tmax, p1->ymax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (r = 0; r < p1->rmax; r++)
            for (s = 0; s < p1->smax; s++)
            for (t = 0; t < p1->tmax; t++)
            for (y = 0; y < p1->ymax; y++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[r][s][t][y][x] = p1->pix[r][s][t][z][y][x];
        } break;

        default :
            NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
            return NULL;
    }

    return np2;
}

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

Npic_image *NpicCreateSlice_y (Npic_image *np1, int y)
{
    Npic_image *np2 = NULL;

    if (NpicImageIsOK (np1, __func__) != NPIC_SUCCESS) return NULL;

    switch (np1->type) {

        case NPIC_IMAGE_3C : {
            Npic_image_3c *p1 = NpicCastImage (np1);
            Npic_image_2c *p2;
            int z, x;

            if (y < 0 || y >= p1->ymax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_2c (
                p1->zmax, p1->xmax, 
                0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (z = 0; z < p1->zmax; z++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[z][x] = p1->pix[z][y][x];
        } break;

        case NPIC_IMAGE_3L : {
            Npic_image_3l *p1 = NpicCastImage (np1);
            Npic_image_2l *p2;
            int z, x;

            if (y < 0 || y >= p1->ymax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_2l (
                p1->zmax, p1->xmax, 
                0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (z = 0; z < p1->zmax; z++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[z][x] = p1->pix[z][y][x];
        } break;

        case NPIC_IMAGE_3D : {
            Npic_image_3d *p1 = NpicCastImage (np1);
            Npic_image_2d *p2;
            int z, x;

            if (y < 0 || y >= p1->ymax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_2d (
                p1->zmax, p1->xmax, 
                0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (z = 0; z < p1->zmax; z++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[z][x] = p1->pix[z][y][x];
        } break;

        case NPIC_IMAGE_3Q : {
            Npic_image_3q *p1 = NpicCastImage (np1);
            Npic_image_2q *p2;
            int z, x;

            if (y < 0 || y >= p1->ymax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_2q (
                p1->zmax, p1->xmax, 
                0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (z = 0; z < p1->zmax; z++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[z][x] = p1->pix[z][y][x];
        } break;

        case NPIC_IMAGE_4C : {
            Npic_image_4c *p1 = NpicCastImage (np1);
            Npic_image_3c *p2;
            int t, z, x;

            if (y < 0 || y >= p1->ymax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_3c (
                p1->tmax, p1->zmax, p1->xmax, 
                0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (t = 0; t < p1->tmax; t++)
            for (z = 0; z < p1->zmax; z++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[t][z][x] = p1->pix[t][z][y][x];
        } break;

        case NPIC_IMAGE_4L : {
            Npic_image_4l *p1 = NpicCastImage (np1);
            Npic_image_3l *p2;
            int t, z, x;

            if (y < 0 || y >= p1->ymax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_3l (
                p1->tmax, p1->zmax, p1->xmax, 
                0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (t = 0; t < p1->tmax; t++)
            for (z = 0; z < p1->zmax; z++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[t][z][x] = p1->pix[t][z][y][x];
        } break;

        case NPIC_IMAGE_4D : {
            Npic_image_4d *p1 = NpicCastImage (np1);
            Npic_image_3d *p2;
            int t, z, x;

            if (y < 0 || y >= p1->ymax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_3d (
                p1->tmax, p1->zmax, p1->xmax, 
                0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (t = 0; t < p1->tmax; t++)
            for (z = 0; z < p1->zmax; z++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[t][z][x] = p1->pix[t][z][y][x];
        } break;

        case NPIC_IMAGE_4Q : {
            Npic_image_4q *p1 = NpicCastImage (np1);
            Npic_image_3q *p2;
            int t, z, x;

            if (y < 0 || y >= p1->ymax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_3q (
                p1->tmax, p1->zmax, p1->xmax, 
                0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (t = 0; t < p1->tmax; t++)
            for (z = 0; z < p1->zmax; z++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[t][z][x] = p1->pix[t][z][y][x];
        } break;

        case NPIC_IMAGE_5C : {
            Npic_image_5c *p1 = NpicCastImage (np1);
            Npic_image_4c *p2;
            int s, t, z, x;

            if (y < 0 || y >= p1->ymax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4c (
                p1->smax, p1->tmax, p1->zmax, p1->xmax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (s = 0; s < p1->smax; s++)
            for (t = 0; t < p1->tmax; t++)
            for (z = 0; z < p1->zmax; z++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[s][t][z][x] = p1->pix[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_5L : {
            Npic_image_5l *p1 = NpicCastImage (np1);
            Npic_image_4l *p2;
            int s, t, z, x;

            if (y < 0 || y >= p1->ymax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4l (
                p1->smax, p1->tmax, p1->zmax, p1->xmax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (s = 0; s < p1->smax; s++)
            for (t = 0; t < p1->tmax; t++)
            for (z = 0; z < p1->zmax; z++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[s][t][z][x] = p1->pix[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_5D : {
            Npic_image_5d *p1 = NpicCastImage (np1);
            Npic_image_4d *p2;
            int s, t, z, x;

            if (y < 0 || y >= p1->ymax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4d (
                p1->smax, p1->tmax, p1->zmax, p1->xmax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (s = 0; s < p1->smax; s++)
            for (t = 0; t < p1->tmax; t++)
            for (z = 0; z < p1->zmax; z++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[s][t][z][x] = p1->pix[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_5Q : {
            Npic_image_5q *p1 = NpicCastImage (np1);
            Npic_image_4q *p2;
            int s, t, z, x;

            if (y < 0 || y >= p1->ymax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4q (
                p1->smax, p1->tmax, p1->zmax, p1->xmax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (s = 0; s < p1->smax; s++)
            for (t = 0; t < p1->tmax; t++)
            for (z = 0; z < p1->zmax; z++)
            for (x = 0; x < p1->xmax; x++)
                p2->pix[s][t][z][x] = p1->pix[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6C : {
            Npic_image_6c *p1 = NpicCastImage (np1);
            Npic_image_5c *p2;
            int r, s, t, z, x;

            if (y < 0 || y >= p1->ymax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5c (
                p1->rmax, p1->smax, p1->tmax, p1->zmax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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 (x = 0; x < p1->xmax; x++)
                p2->pix[r][s][t][z][x] = p1->pix[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6L : {
            Npic_image_6l *p1 = NpicCastImage (np1);
            Npic_image_5l *p2;
            int r, s, t, z, x;

            if (y < 0 || y >= p1->ymax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5l (
                p1->rmax, p1->smax, p1->tmax, p1->zmax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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 (x = 0; x < p1->xmax; x++)
                p2->pix[r][s][t][z][x] = p1->pix[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6D : {
            Npic_image_6d *p1 = NpicCastImage (np1);
            Npic_image_5d *p2;
            int r, s, t, z, x;

            if (y < 0 || y >= p1->ymax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5d (
                p1->rmax, p1->smax, p1->tmax, p1->zmax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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 (x = 0; x < p1->xmax; x++)
                p2->pix[r][s][t][z][x] = p1->pix[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6Q : {
            Npic_image_6q *p1 = NpicCastImage (np1);
            Npic_image_5q *p2;
            int r, s, t, z, x;

            if (y < 0 || y >= p1->ymax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5q (
                p1->rmax, p1->smax, p1->tmax, p1->zmax, p1->xmax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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 (x = 0; x < p1->xmax; x++)
                p2->pix[r][s][t][z][x] = p1->pix[r][s][t][z][y][x];
        } break;

        default :
            NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
            return NULL;
    }

    return np2;
}

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

Npic_image *NpicCreateSlice_x (Npic_image *np1, int x)
{
    Npic_image *np2 = NULL;

    if (NpicImageIsOK (np1, __func__) != NPIC_SUCCESS) return NULL;

    switch (np1->type) {

        case NPIC_IMAGE_3C : {
            Npic_image_3c *p1 = NpicCastImage (np1);
            Npic_image_2c *p2;
            int z, y;

            if (x < 0 || x >= p1->xmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_2c (
                p1->zmax, p1->ymax, 
                0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (z = 0; z < p1->zmax; z++)
            for (y = 0; y < p1->ymax; y++)
                p2->pix[z][y] = p1->pix[z][y][x];
        } break;

        case NPIC_IMAGE_3L : {
            Npic_image_3l *p1 = NpicCastImage (np1);
            Npic_image_2l *p2;
            int z, y;

            if (x < 0 || x >= p1->xmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_2l (
                p1->zmax, p1->ymax, 
                0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (z = 0; z < p1->zmax; z++)
            for (y = 0; y < p1->ymax; y++)
                p2->pix[z][y] = p1->pix[z][y][x];
        } break;

        case NPIC_IMAGE_3D : {
            Npic_image_3d *p1 = NpicCastImage (np1);
            Npic_image_2d *p2;
            int z, y;

            if (x < 0 || x >= p1->xmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_2d (
                p1->zmax, p1->ymax, 
                0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (z = 0; z < p1->zmax; z++)
            for (y = 0; y < p1->ymax; y++)
                p2->pix[z][y] = p1->pix[z][y][x];
        } break;

        case NPIC_IMAGE_3Q : {
            Npic_image_3q *p1 = NpicCastImage (np1);
            Npic_image_2q *p2;
            int z, y;

            if (x < 0 || x >= p1->xmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_2q (
                p1->zmax, p1->ymax, 
                0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (z = 0; z < p1->zmax; z++)
            for (y = 0; y < p1->ymax; y++)
                p2->pix[z][y] = p1->pix[z][y][x];
        } break;

        case NPIC_IMAGE_4C : {
            Npic_image_4c *p1 = NpicCastImage (np1);
            Npic_image_3c *p2;
            int t, z, y;

            if (x < 0 || x >= p1->xmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_3c (
                p1->tmax, p1->zmax, p1->ymax, 
                0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (t = 0; t < p1->tmax; t++)
            for (z = 0; z < p1->zmax; z++)
            for (y = 0; y < p1->ymax; y++)
                p2->pix[t][z][y] = p1->pix[t][z][y][x];
        } break;

        case NPIC_IMAGE_4L : {
            Npic_image_4l *p1 = NpicCastImage (np1);
            Npic_image_3l *p2;
            int t, z, y;

            if (x < 0 || x >= p1->xmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_3l (
                p1->tmax, p1->zmax, p1->ymax, 
                0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (t = 0; t < p1->tmax; t++)
            for (z = 0; z < p1->zmax; z++)
            for (y = 0; y < p1->ymax; y++)
                p2->pix[t][z][y] = p1->pix[t][z][y][x];
        } break;

        case NPIC_IMAGE_4D : {
            Npic_image_4d *p1 = NpicCastImage (np1);
            Npic_image_3d *p2;
            int t, z, y;

            if (x < 0 || x >= p1->xmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_3d (
                p1->tmax, p1->zmax, p1->ymax, 
                0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (t = 0; t < p1->tmax; t++)
            for (z = 0; z < p1->zmax; z++)
            for (y = 0; y < p1->ymax; y++)
                p2->pix[t][z][y] = p1->pix[t][z][y][x];
        } break;

        case NPIC_IMAGE_4Q : {
            Npic_image_4q *p1 = NpicCastImage (np1);
            Npic_image_3q *p2;
            int t, z, y;

            if (x < 0 || x >= p1->xmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_3q (
                p1->tmax, p1->zmax, p1->ymax, 
                0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            for (t = 0; t < p1->tmax; t++)
            for (z = 0; z < p1->zmax; z++)
            for (y = 0; y < p1->ymax; y++)
                p2->pix[t][z][y] = p1->pix[t][z][y][x];
        } break;

        case NPIC_IMAGE_5C : {
            Npic_image_5c *p1 = NpicCastImage (np1);
            Npic_image_4c *p2;
            int s, t, z, y;

            if (x < 0 || x >= p1->xmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4c (
                p1->smax, p1->tmax, p1->zmax, p1->ymax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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++)
                p2->pix[s][t][z][y] = p1->pix[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_5L : {
            Npic_image_5l *p1 = NpicCastImage (np1);
            Npic_image_4l *p2;
            int s, t, z, y;

            if (x < 0 || x >= p1->xmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4l (
                p1->smax, p1->tmax, p1->zmax, p1->ymax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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++)
                p2->pix[s][t][z][y] = p1->pix[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_5D : {
            Npic_image_5d *p1 = NpicCastImage (np1);
            Npic_image_4d *p2;
            int s, t, z, y;

            if (x < 0 || x >= p1->xmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4d (
                p1->smax, p1->tmax, p1->zmax, p1->ymax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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++)
                p2->pix[s][t][z][y] = p1->pix[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_5Q : {
            Npic_image_5q *p1 = NpicCastImage (np1);
            Npic_image_4q *p2;
            int s, t, z, y;

            if (x < 0 || x >= p1->xmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_4q (
                p1->smax, p1->tmax, p1->zmax, p1->ymax, 
                0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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++)
                p2->pix[s][t][z][y] = p1->pix[s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6C : {
            Npic_image_6c *p1 = NpicCastImage (np1);
            Npic_image_5c *p2;
            int r, s, t, z, y;

            if (x < 0 || x >= p1->xmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5c (
                p1->rmax, p1->smax, p1->tmax, p1->zmax, p1->ymax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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++)
                p2->pix[r][s][t][z][y] = p1->pix[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6L : {
            Npic_image_6l *p1 = NpicCastImage (np1);
            Npic_image_5l *p2;
            int r, s, t, z, y;

            if (x < 0 || x >= p1->xmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5l (
                p1->rmax, p1->smax, p1->tmax, p1->zmax, p1->ymax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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++)
                p2->pix[r][s][t][z][y] = p1->pix[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6D : {
            Npic_image_6d *p1 = NpicCastImage (np1);
            Npic_image_5d *p2;
            int r, s, t, z, y;

            if (x < 0 || x >= p1->xmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5d (
                p1->rmax, p1->smax, p1->tmax, p1->zmax, p1->ymax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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++)
                p2->pix[r][s][t][z][y] = p1->pix[r][s][t][z][y][x];
        } break;

        case NPIC_IMAGE_6Q : {
            Npic_image_6q *p1 = NpicCastImage (np1);
            Npic_image_5q *p2;
            int r, s, t, z, y;

            if (x < 0 || x >= p1->xmax) {
                NpicError (__func__, NPIC_ERR_SLICE_RG, "");
                return NULL;
            }

            np2 = NpicCreateImage_5q (
                p1->rmax, p1->smax, p1->tmax, p1->zmax, p1->ymax, 
                0, 0, 0, 0, 0);
            if (np2 == NULL) return NULL;
            p2 = NpicCastImage (np2);

            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++)
                p2->pix[r][s][t][z][y] = p1->pix[r][s][t][z][y][x];
        } break;

        default :
            NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
            return NULL;
    }

    return np2;
}

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