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

/*
 * image_border.c - 05/01/2009
 *
 * Manage border
*/


#include <npic.h>


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

/*
 * Change border width of np.
 * The image pixels are unchanged ; the border pixels are set to 0.
 *
 * rbor, sbor, tbor or zbor are ignored depending on dimension.
 * Do nothing if np is not ok. set not ok on error. Verbose.
*/

void NpicSetBorderWidth (Npic_image *np, int tbor, int zbor, int ybor, int xbor)
{
    NpicSetBorderWidth6 (np, 0, 0, tbor, zbor, ybor, xbor);
}

void NpicSetBorderWidth6 (Npic_image *np, int rbor, int sbor, int tbor, 
        int zbor, int ybor, int xbor)
{
    Npic_image *tmp;
    
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS)
        return;
        
    if (rbor < 0 || sbor < 0 || tbor < 0 || zbor < 0 || ybor < 0 || xbor < 0) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_BAD_SIZE, "");
        return;
    }
    
    if (rbor == np->gen.rbor && sbor == np->gen.sbor &&
        tbor == np->gen.tbor && zbor == np->gen.zbor &&
        ybor == np->gen.ybor && xbor == np->gen.xbor) return;
    
    tmp = NpicDupImageB6 (np, rbor, sbor, tbor, zbor, ybor, xbor);
    if (tmp == NULL) { np->gen.ok = NPIC_ERROR; return; };
    
    NpicCopyImageI (tmp, np);
    NpicSwapImage (tmp, np);
    NpicDestroyImage (tmp);
}


/*
 * Change all border widths of np to same value.
 * The image pixels are unchanged ; the border pixels are set to 0.
 *
 * Do nothing if np is not ok. set not ok on error. Verbose.
*/

void NpicSetBorderWidthSame (Npic_image *np, int bord)
{
    NpicSetBorderWidth6 (np, bord, bord, bord, bord, bord, bord);
}


/*
 * Change all border widths of np to same value if one was smaller.
 * The image pixels are unchanged ; the border pixels are set to 0.
 *
 * Do nothing if np is not ok. set not ok on error. Verbose.
*/

void NpicSetBorderWidthMin (Npic_image *np, int bord)
{
    if (  np->gen.xbor < bord ||
          np->gen.ybor < bord ||
         (np->gen.zbor < bord && np->gen.dim >= 3) ||
         (np->gen.tbor < bord && np->gen.dim >= 4) ||
         (np->gen.sbor < bord && np->gen.dim >= 5) ||
         (np->gen.rbor < bord && np->gen.dim >= 6) 
       ) NpicSetBorderWidth6 (np, bord, bord, bord, bord, bord, bord);
}


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

/*
 * Set each pixel to zero, including border pixels.
 *
 * Do nothing if np is not ok. Verbose.
*/

void NpicFillWholeZero (Npic_image *np)
{
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS)
        return;
        
    memset (np->gen.vec_, 0, np->gen.pixtot * np->gen.pixsize);
}


/*
 * Set all pixels to the value val1, including border pixels.
 *
 * Do nothing if np is not ok. set not ok on error. Verbose.
*/

void NpicFillWhole_i (Npic_image *np, int val1)
{
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS)
        return;

    switch (np->type) {
    
        case NPIC_IMAGE_2C : {
            Npic_image_2c *p = NpicCastImage (np);
            size_t k;
        
            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

        case NPIC_IMAGE_3C : {
            Npic_image_3c *p = NpicCastImage (np);
            size_t k;
        
            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

        case NPIC_IMAGE_4C : {
            Npic_image_4c *p = NpicCastImage (np);
            size_t k;
        
            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

        case NPIC_IMAGE_5C : {
            Npic_image_5c *p = NpicCastImage (np);
            size_t k;
        
            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

        case NPIC_IMAGE_6C : {
            Npic_image_6c *p = NpicCastImage (np);
            size_t k;
        
            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

        case NPIC_IMAGE_2L : {
            Npic_image_2l *p = NpicCastImage (np);
            size_t k;
        
            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

        case NPIC_IMAGE_3L : {
            Npic_image_3l *p = NpicCastImage (np);
            size_t k;
        
            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

        case NPIC_IMAGE_4L : {
            Npic_image_4l *p = NpicCastImage (np);
            size_t k;
        
            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

        case NPIC_IMAGE_5L : {
            Npic_image_5l *p = NpicCastImage (np);
            size_t k;
        
            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

        case NPIC_IMAGE_6L : {
            Npic_image_6l *p = NpicCastImage (np);
            size_t k;
        
            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

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

void NpicFillWhole_d (Npic_image *np, double val1)
{
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS)
        return;

    switch (np->type) {
    
        case NPIC_IMAGE_2D : {
            Npic_image_2d *p = NpicCastImage (np);
            size_t k;
        
            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

        case NPIC_IMAGE_3D : {
            Npic_image_3d *p = NpicCastImage (np);
            size_t k;
        
            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

        case NPIC_IMAGE_4D : {
            Npic_image_4d *p = NpicCastImage (np);
            size_t k;
        
            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

        case NPIC_IMAGE_5D : {
            Npic_image_5d *p = NpicCastImage (np);
            size_t k;
        
            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

        case NPIC_IMAGE_6D : {
            Npic_image_6d *p = NpicCastImage (np);
            size_t k;
        
            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

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

void NpicFillWhole_q (Npic_image *np, int a, int b, int c, int d)
{
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS)
        return;

    switch (np->type) {

        case NPIC_IMAGE_2Q : {
            Npic_image_2q *p = NpicCastImage (np);
            size_t k;
            Npic_q val1;
            val1.a = a; val1.b = b ; val1.c = c; val1.d = d;

            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

        case NPIC_IMAGE_3Q : {
            Npic_image_3q *p = NpicCastImage (np);
            size_t k;
            Npic_q val1;
            val1.a = a; val1.b = b ; val1.c = c; val1.d = d;

            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

        case NPIC_IMAGE_4Q : {
            Npic_image_4q *p = NpicCastImage (np);
            size_t k;
            Npic_q val1;
            val1.a = a; val1.b = b ; val1.c = c; val1.d = d;

            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

        case NPIC_IMAGE_5Q : {
            Npic_image_5q *p = NpicCastImage (np);
            size_t k;
            Npic_q val1;
            val1.a = a; val1.b = b ; val1.c = c; val1.d = d;

            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

        case NPIC_IMAGE_6Q : {
            Npic_image_6q *p = NpicCastImage (np);
            size_t k;
            Npic_q val1;
            val1.a = a; val1.b = b ; val1.c = c; val1.d = d;

            for (k = 0; k < p->pixtot; k++)
                p->vec[k] = val1;
            return;
        }

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


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

/*
 * Set border pixels to the value val1.
 * The image pixels are unchanged.
 *
 * Do nothing if np is not ok. set not ok on error. Verbose.
*/

void NpicFillBorder_i (Npic_image *np, int val1)
{    
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS)
        return;
    
    /* Remark: in the following, corner pixels are labelled several times;
       the program was more easy to write in this manner. The overcost
       is negligible */
    
    switch (np->type) {
    
        case NPIC_IMAGE_2C : {
            Npic_image_2c *p = NpicCastImage (np);
            int y, x;
        
            for (y = -p->ybor; y <               0; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[y][x] = val1;
        
            return;
        }

        case NPIC_IMAGE_2L : {
            Npic_image_2l *p = NpicCastImage (np);
            int y, x;
        
            for (y = -p->ybor; y <               0; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[y][x] = val1;
        
            return;
        }

        case NPIC_IMAGE_3C : {
            Npic_image_3c *p = NpicCastImage (np);
            int z, y, x;
        
            for (z = -p->zbor; z <               0; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[z][y][x] = val1;
        
            for (z =  p->zmax; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[z][y][x] = val1;

            for (y = -p->ybor; y <               0; y++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[z][y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[z][y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[z][y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[z][y][x] = val1;
        
            return;
        }

        case NPIC_IMAGE_3L : {
            Npic_image_3l *p = NpicCastImage (np);
            int z, y, x;
        
            for (z = -p->zbor; z <               0; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[z][y][x] = val1;
        
            for (z =  p->zmax; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[z][y][x] = val1;

            for (y = -p->ybor; y <               0; y++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[z][y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[z][y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[z][y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[z][y][x] = val1;
        
            return;
        }

        case NPIC_IMAGE_4C : {
            Npic_image_4c *p = NpicCastImage (np);
            int t, z, y, x;
        
            for (t = -p->tbor; t <               0; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;
        
            for (t =  p->tmax; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;

            for (z = -p->zbor; z <               0; z++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;
        
            for (z =  p->zmax; z < p->zmax+p->zbor; z++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;

            for (y = -p->ybor; y <               0; y++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[t][z][y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[t][z][y][x] = val1;
        
            return;
        }

        case NPIC_IMAGE_4L : {
            Npic_image_4l *p = NpicCastImage (np);
            int t, z, y, x;
        
            for (t = -p->tbor; t <               0; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;
        
            for (t =  p->tmax; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;

            for (z = -p->zbor; z <               0; z++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;
        
            for (z =  p->zmax; z < p->zmax+p->zbor; z++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;

            for (y = -p->ybor; y <               0; y++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[t][z][y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[t][z][y][x] = val1;
        
            return;
        }

        case NPIC_IMAGE_5C : {
            Npic_image_5c *p = NpicCastImage (np);
            int s, t, z, y, x;
        
            for (s = -p->sbor; s <               0; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (s =  p->smax; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;

            for (t = -p->tbor; t <               0; t++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (t =  p->tmax; t < p->tmax+p->tbor; t++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;

            for (z = -p->zbor; z <               0; z++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (z =  p->zmax; z < p->zmax+p->zbor; z++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;

            for (y = -p->ybor; y <               0; y++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[s][t][z][y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[s][t][z][y][x] = val1;
        
            return;
        }

        case NPIC_IMAGE_5L : {
            Npic_image_5l *p = NpicCastImage (np);
            int s, t, z, y, x;
        
            for (s = -p->sbor; s <               0; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (s =  p->smax; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;

            for (t = -p->tbor; t <               0; t++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (t =  p->tmax; t < p->tmax+p->tbor; t++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;

            for (z = -p->zbor; z <               0; z++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (z =  p->zmax; z < p->zmax+p->zbor; z++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;

            for (y = -p->ybor; y <               0; y++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[s][t][z][y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[s][t][z][y][x] = val1;
        
            return;
        }

        case NPIC_IMAGE_6C : {
            Npic_image_6c *p = NpicCastImage (np);
            int r, s, t, z, y, x;
        
            for (r = -p->rbor; r <               0; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (r =  p->rmax; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;

            for (s = -p->sbor; s <               0; s++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (s =  p->smax; s < p->smax+p->sbor; s++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;

            for (t = -p->tbor; t <               0; t++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (t =  p->tmax; t < p->tmax+p->tbor; t++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;

            for (z = -p->zbor; z <               0; z++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (z =  p->zmax; z < p->zmax+p->zbor; z++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;

            for (y = -p->ybor; y <               0; y++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[r][s][t][z][y][x] = val1;
        
            return;
        }

        case NPIC_IMAGE_6L : {
            Npic_image_6l *p = NpicCastImage (np);
            int r, s, t, z, y, x;
        
            for (r = -p->rbor; r <               0; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (r =  p->rmax; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;

            for (s = -p->sbor; s <               0; s++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (s =  p->smax; s < p->smax+p->sbor; s++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;

            for (t = -p->tbor; t <               0; t++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (t =  p->tmax; t < p->tmax+p->tbor; t++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;

            for (z = -p->zbor; z <               0; z++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (z =  p->zmax; z < p->zmax+p->zbor; z++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;

            for (y = -p->ybor; y <               0; y++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[r][s][t][z][y][x] = val1;
        
            return;
        }

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

void NpicFillBorder_d (Npic_image *np, double val1)
{    
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS)
        return;

    switch (np->type) {
    
        case NPIC_IMAGE_2D : {
            Npic_image_2d *p = NpicCastImage (np);
            int y, x;
        
            for (y = -p->ybor; y <               0; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[y][x] = val1;
        
            return;
        }

        case NPIC_IMAGE_3D : {
            Npic_image_3d *p = NpicCastImage (np);
            int z, y, x;
        
            for (z = -p->zbor; z <               0; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[z][y][x] = val1;
        
            for (z =  p->zmax; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[z][y][x] = val1;

            for (y = -p->ybor; y <               0; y++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[z][y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[z][y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[z][y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[z][y][x] = val1;
        
            return;
        }

        case NPIC_IMAGE_4D : {
            Npic_image_4d *p = NpicCastImage (np);
            int t, z, y, x;
        
            for (t = -p->tbor; t <               0; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;
        
            for (t =  p->tmax; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;

            for (z = -p->zbor; z <               0; z++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;
        
            for (z =  p->zmax; z < p->zmax+p->zbor; z++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;

            for (y = -p->ybor; y <               0; y++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[t][z][y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[t][z][y][x] = val1;
        
            return;
        }

        case NPIC_IMAGE_5D : {
            Npic_image_5d *p = NpicCastImage (np);
            int s, t, z, y, x;
        
            for (s = -p->sbor; s <               0; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (s =  p->smax; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;

            for (t = -p->tbor; t <               0; t++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (t =  p->tmax; t < p->tmax+p->tbor; t++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;

            for (z = -p->zbor; z <               0; z++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (z =  p->zmax; z < p->zmax+p->zbor; z++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;

            for (y = -p->ybor; y <               0; y++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[s][t][z][y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[s][t][z][y][x] = val1;
        
            return;
        }

        case NPIC_IMAGE_6D : {
            Npic_image_6d *p = NpicCastImage (np);
            int r, s, t, z, y, x;
        
            for (r = -p->rbor; r <               0; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (r =  p->rmax; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;

            for (s = -p->sbor; s <               0; s++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (s =  p->smax; s < p->smax+p->sbor; s++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;

            for (t = -p->tbor; t <               0; t++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (t =  p->tmax; t < p->tmax+p->tbor; t++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;

            for (z = -p->zbor; z <               0; z++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (z =  p->zmax; z < p->zmax+p->zbor; z++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;

            for (y = -p->ybor; y <               0; y++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[r][s][t][z][y][x] = val1;
        
            return;
        }

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

void NpicFillBorder_q (Npic_image *np, int a, int b, int c, int d)
{    
    Npic_q val1;
    val1.a = a; val1.b = b ; val1.c = c; val1.d = d;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS)
        return;

    switch (np->type) {
    
        case NPIC_IMAGE_2Q : {
            Npic_image_2q *p = NpicCastImage (np);
            int y, x;
        
            for (y = -p->ybor; y <               0; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[y][x] = val1;
        
            return;
        }

        case NPIC_IMAGE_3Q : {
            Npic_image_3q *p = NpicCastImage (np);
            int z, y, x;
        
            for (z = -p->zbor; z <               0; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[z][y][x] = val1;
        
            for (z =  p->zmax; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[z][y][x] = val1;

            for (y = -p->ybor; y <               0; y++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[z][y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[z][y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[z][y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[z][y][x] = val1;
        
            return;
        }

        case NPIC_IMAGE_4Q : {
            Npic_image_4q *p = NpicCastImage (np);
            int t, z, y, x;
        
            for (t = -p->tbor; t <               0; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;
        
            for (t =  p->tmax; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;

            for (z = -p->zbor; z <               0; z++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;
        
            for (z =  p->zmax; z < p->zmax+p->zbor; z++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;

            for (y = -p->ybor; y <               0; y++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[t][z][y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[t][z][y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[t][z][y][x] = val1;
        
            return;
        }

        case NPIC_IMAGE_5Q : {
            Npic_image_5q *p = NpicCastImage (np);
            int s, t, z, y, x;
        
            for (s = -p->sbor; s <               0; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (s =  p->smax; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;

            for (t = -p->tbor; t <               0; t++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (t =  p->tmax; t < p->tmax+p->tbor; t++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;

            for (z = -p->zbor; z <               0; z++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (z =  p->zmax; z < p->zmax+p->zbor; z++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;

            for (y = -p->ybor; y <               0; y++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[s][t][z][y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[s][t][z][y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[s][t][z][y][x] = val1;
        
            return;
        }

        case NPIC_IMAGE_6Q : {
            Npic_image_6q *p = NpicCastImage (np);
            int r, s, t, z, y, x;
        
            for (r = -p->rbor; r <               0; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (r =  p->rmax; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;

            for (s = -p->sbor; s <               0; s++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (s =  p->smax; s < p->smax+p->sbor; s++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;

            for (t = -p->tbor; t <               0; t++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (t =  p->tmax; t < p->tmax+p->tbor; t++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;

            for (z = -p->zbor; z <               0; z++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (z =  p->zmax; z < p->zmax+p->zbor; z++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;

            for (y = -p->ybor; y <               0; y++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (y =  p->ymax; y < p->ymax+p->ybor; y++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (x = -p->xbor; x < p->xmax+p->xbor; x++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (x = -p->xbor; x <               0; x++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[r][s][t][z][y][x] = val1;
        
            for (x =  p->xmax; x < p->xmax+p->xbor; x++)
            for (r = -p->rbor; r < p->rmax+p->rbor; r++)
            for (s = -p->sbor; s < p->smax+p->sbor; s++)
            for (t = -p->tbor; t < p->tmax+p->tbor; t++)
            for (z = -p->zbor; z < p->zmax+p->zbor; z++)
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
                p->pix[r][s][t][z][y][x] = val1;
        
            return;
        }

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


/*
 * Fill the border with image pixels. The image pixels are unchanged.
 * The Line 1 is copied on line -1, line 2 on line -2, etc; same for rows, etc.
 * Useful for linear filters.
 *
 * Do nothing if np is not ok. set not ok on error. Verbose.
*/

void NpicMirrorBorder (Npic_image *np)
{
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS)
        return;
    
    if ( np->gen.xbor <= 0 || np->gen.xbor >= np->gen.xmax || 
         np->gen.ybor <= 0 || np->gen.ybor >= np->gen.ymax ||
        (np->gen.dim >=3 && (np->gen.zbor <= 0 || np->gen.zbor >= np->gen.zmax)) ||
        (np->gen.dim >=4 && (np->gen.tbor <= 0 || np->gen.tbor >= np->gen.tmax)) ||
        (np->gen.dim >=5 && (np->gen.sbor <= 0 || np->gen.sbor >= np->gen.smax)) ||
        (np->gen.dim >=6 && (np->gen.rbor <= 0 || np->gen.rbor >= np->gen.rmax)) )
    {
        np->gen.ok = NpicError (__func__, NPIC_ERR_BAD_SIZE, "");
        return;
    }

    switch (np->type) {
    
        case NPIC_IMAGE_2C : {
            Npic_image_2c *p = NpicCastImage (np);
            int y, x;
        
            for (y = 1; y <= p->ybor; y++)
            for (x = 0; x < p->xmax; x++) {
                p->pix[-y][x] = p->pix[y][x]; 
                p->pix[p->ymax-1+y][x] = p->pix[p->ymax-1-y][x];
            }
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = 1; x <= p->xbor; x++) {
                p->pix[y][-x] = p->pix[y][x]; 
                p->pix[y][p->xmax-1+x] = p->pix[y][p->xmax-1-x];
            }
            return;
        } 

        case NPIC_IMAGE_2L : {
            Npic_image_2l *p = NpicCastImage (np);
            int y, x;
        
            for (y = 1; y <= p->ybor; y++)
            for (x = 0; x < p->xmax; x++) {
                p->pix[-y][x] = p->pix[y][x]; 
                p->pix[p->ymax-1+y][x] = p->pix[p->ymax-1-y][x];
            }
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = 1; x <= p->xbor; x++) {
                p->pix[y][-x] = p->pix[y][x]; 
                p->pix[y][p->xmax-1+x] = p->pix[y][p->xmax-1-x];
            }
            return;
        } 

        case NPIC_IMAGE_2D : {
            Npic_image_2d *p = NpicCastImage (np);
            int y, x;
        
            for (y = 1; y <= p->ybor; y++)
            for (x = 0; x < p->xmax; x++) {
                p->pix[-y][x] = p->pix[y][x]; 
                p->pix[p->ymax-1+y][x] = p->pix[p->ymax-1-y][x];
            }
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = 1; x <= p->xbor; x++) {
                p->pix[y][-x] = p->pix[y][x]; 
                p->pix[y][p->xmax-1+x] = p->pix[y][p->xmax-1-x];
            }
            return;
        } 

        case NPIC_IMAGE_2Q : {
            Npic_image_2q *p = NpicCastImage (np);
            int y, x;
        
            for (y = 1; y <= p->ybor; y++)
            for (x = 0; x < p->xmax; x++) {
                p->pix[-y][x] = p->pix[y][x]; 
                p->pix[p->ymax-1+y][x] = p->pix[p->ymax-1-y][x];
            }
            for (y = -p->ybor; y < p->ymax+p->ybor; y++)
            for (x = 1; x <= p->xbor; x++) {
                p->pix[y][-x] = p->pix[y][x]; 
                p->pix[y][p->xmax-1+x] = p->pix[y][p->xmax-1-x];
            }
            return;
        } 

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


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