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

/*
 * calc_draw.c - 05/01/2009
 *
 * Draw in image
*/


#include <npic.h>


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

/*
 * Draw a rectangle bounded by P and Q, with pixel value val1.
 * P and Q can be outside image.
 *
 * Do not modify other pixels neither border pixels.
 * Do nothing if np is not ok. set not ok on error. Verbose.
*/

void NpicDrawRect_2c (Npic_image *np, 
        int yP, int xP, 
        int yQ, int xQ, 
        Npic_c val1)
{
    Npic_image_2c *p1 = NpicCastImage(np);
    int y, x;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_2C) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;

    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[y][x] = val1;
}

void NpicDrawRect_2l (Npic_image *np, 
        int yP, int xP, 
        int yQ, int xQ, 
        Npic_l val1)
{
    Npic_image_2l *p1 = NpicCastImage(np);
    int y, x;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_2L) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;

    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[y][x] = val1;
}

void NpicDrawRect_2d (Npic_image *np, 
        int yP, int xP, 
        int yQ, int xQ, 
        Npic_d val1)
{
    Npic_image_2d *p1 = NpicCastImage(np);
    int y, x;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_2D) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;

    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[y][x] = val1;
}

void NpicDrawRect_3c (Npic_image *np, 
        int zP, int yP, int xP, 
        int zQ, int yQ, int xQ, 
        Npic_c val1)
{
    Npic_image_3c *p1 = NpicCastImage(np);
    int z, y, x;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_3C) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (zP < 0) zP = 0; if (zP >= np->gen.zmax) zP = np->gen.zmax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;
    if (zQ < 0) zQ = 0; if (zQ >= np->gen.zmax) zQ = np->gen.zmax-1;

    for (z = zP; z <= zQ; z++)
    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[z][y][x] = val1;
}

void NpicDrawRect_3l (Npic_image *np, 
        int zP, int yP, int xP, 
        int zQ, int yQ, int xQ, 
        Npic_l val1)
{
    Npic_image_3l *p1 = NpicCastImage(np);
    int z, y, x;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_3L) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (zP < 0) zP = 0; if (zP >= np->gen.zmax) zP = np->gen.zmax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;
    if (zQ < 0) zQ = 0; if (zQ >= np->gen.zmax) zQ = np->gen.zmax-1;

    for (z = zP; z <= zQ; z++)
    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[z][y][x] = val1;
}

void NpicDrawRect_3d (Npic_image *np, 
        int zP, int yP, int xP, 
        int zQ, int yQ, int xQ, 
        Npic_d val1)
{
    Npic_image_3d *p1 = NpicCastImage(np);
    int z, y, x;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_3D) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (zP < 0) zP = 0; if (zP >= np->gen.zmax) zP = np->gen.zmax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;
    if (zQ < 0) zQ = 0; if (zQ >= np->gen.zmax) zQ = np->gen.zmax-1;

    for (z = zP; z <= zQ; z++)
    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[z][y][x] = val1;
}

void NpicDrawRect_4c (Npic_image *np, 
        int tP, int zP, int yP, int xP, 
        int tQ, int zQ, int yQ, int xQ, 
        Npic_c val1)
{
    Npic_image_4c *p1 = NpicCastImage(np);
    int t, z, y, x;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_4C) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (zP < 0) zP = 0; if (zP >= np->gen.zmax) zP = np->gen.zmax-1;
    if (tP < 0) tP = 0; if (tP >= np->gen.tmax) tP = np->gen.tmax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;
    if (zQ < 0) zQ = 0; if (zQ >= np->gen.zmax) zQ = np->gen.zmax-1;
    if (tQ < 0) tQ = 0; if (tQ >= np->gen.tmax) tQ = np->gen.tmax-1;

    for (t = tP; t <= tQ; t++)
    for (z = zP; z <= zQ; z++)
    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[t][z][y][x] = val1;
}

void NpicDrawRect_4l (Npic_image *np, 
        int tP, int zP, int yP, int xP, 
        int tQ, int zQ, int yQ, int xQ, 
        Npic_l val1)
{
    Npic_image_4l *p1 = NpicCastImage(np);
    int t, z, y, x;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_4L) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (zP < 0) zP = 0; if (zP >= np->gen.zmax) zP = np->gen.zmax-1;
    if (tP < 0) tP = 0; if (tP >= np->gen.tmax) tP = np->gen.tmax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;
    if (zQ < 0) zQ = 0; if (zQ >= np->gen.zmax) zQ = np->gen.zmax-1;
    if (tQ < 0) tQ = 0; if (tQ >= np->gen.tmax) tQ = np->gen.tmax-1;

    for (t = tP; t <= tQ; t++)
    for (z = zP; z <= zQ; z++)
    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[t][z][y][x] = val1;
}

void NpicDrawRect_4d (Npic_image *np, 
        int tP, int zP, int yP, int xP, 
        int tQ, int zQ, int yQ, int xQ, 
        Npic_d val1)
{
    Npic_image_4d *p1 = NpicCastImage(np);
    int t, z, y, x;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_4D) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (zP < 0) zP = 0; if (zP >= np->gen.zmax) zP = np->gen.zmax-1;
    if (tP < 0) tP = 0; if (tP >= np->gen.tmax) tP = np->gen.tmax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;
    if (zQ < 0) zQ = 0; if (zQ >= np->gen.zmax) zQ = np->gen.zmax-1;
    if (tQ < 0) tQ = 0; if (tQ >= np->gen.tmax) tQ = np->gen.tmax-1;

    for (t = tP; t <= tQ; t++)
    for (z = zP; z <= zQ; z++)
    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[t][z][y][x] = val1;
}

void NpicDrawRect_5c (Npic_image *np, 
        int sP, int tP, int zP, int yP, int xP, 
        int sQ, int tQ, int zQ, int yQ, int xQ, 
        Npic_c val1)
{
    Npic_image_5c *p1 = NpicCastImage(np);
    int s, t, z, y, x;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_5C) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    if (sP > sQ) { int k = sP; sP = sQ; sQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (zP < 0) zP = 0; if (zP >= np->gen.zmax) zP = np->gen.zmax-1;
    if (tP < 0) tP = 0; if (tP >= np->gen.tmax) tP = np->gen.tmax-1;
    if (sP < 0) sP = 0; if (sP >= np->gen.smax) sP = np->gen.smax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;
    if (zQ < 0) zQ = 0; if (zQ >= np->gen.zmax) zQ = np->gen.zmax-1;
    if (tQ < 0) tQ = 0; if (tQ >= np->gen.tmax) tQ = np->gen.tmax-1;
    if (sQ < 0) sQ = 0; if (sQ >= np->gen.smax) sQ = np->gen.smax-1;

    for (s = sP; s <= sQ; s++)
    for (t = tP; t <= tQ; t++)
    for (z = zP; z <= zQ; z++)
    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[s][t][z][y][x] = val1;
}

void NpicDrawRect_5l (Npic_image *np, 
        int sP, int tP, int zP, int yP, int xP, 
        int sQ, int tQ, int zQ, int yQ, int xQ, 
        Npic_l val1)
{
    Npic_image_5l *p1 = NpicCastImage(np);
    int s, t, z, y, x;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_5L) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    if (sP > sQ) { int k = sP; sP = sQ; sQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (zP < 0) zP = 0; if (zP >= np->gen.zmax) zP = np->gen.zmax-1;
    if (tP < 0) tP = 0; if (tP >= np->gen.tmax) tP = np->gen.tmax-1;
    if (sP < 0) sP = 0; if (sP >= np->gen.smax) sP = np->gen.smax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;
    if (zQ < 0) zQ = 0; if (zQ >= np->gen.zmax) zQ = np->gen.zmax-1;
    if (tQ < 0) tQ = 0; if (tQ >= np->gen.tmax) tQ = np->gen.tmax-1;
    if (sQ < 0) sQ = 0; if (sQ >= np->gen.smax) sQ = np->gen.smax-1;

    for (s = sP; s <= sQ; s++)
    for (t = tP; t <= tQ; t++)
    for (z = zP; z <= zQ; z++)
    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[s][t][z][y][x] = val1;
}

void NpicDrawRect_5d (Npic_image *np, 
        int sP, int tP, int zP, int yP, int xP, 
        int sQ, int tQ, int zQ, int yQ, int xQ, 
        Npic_d val1)
{
    Npic_image_5d *p1 = NpicCastImage(np);
    int s, t, z, y, x;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_5D) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    if (sP > sQ) { int k = sP; sP = sQ; sQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (zP < 0) zP = 0; if (zP >= np->gen.zmax) zP = np->gen.zmax-1;
    if (tP < 0) tP = 0; if (tP >= np->gen.tmax) tP = np->gen.tmax-1;
    if (sP < 0) sP = 0; if (sP >= np->gen.smax) sP = np->gen.smax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;
    if (zQ < 0) zQ = 0; if (zQ >= np->gen.zmax) zQ = np->gen.zmax-1;
    if (tQ < 0) tQ = 0; if (tQ >= np->gen.tmax) tQ = np->gen.tmax-1;
    if (sQ < 0) sQ = 0; if (sQ >= np->gen.smax) sQ = np->gen.smax-1;

    for (s = sP; s <= sQ; s++)
    for (t = tP; t <= tQ; t++)
    for (z = zP; z <= zQ; z++)
    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[s][t][z][y][x] = val1;
}

void NpicDrawRect_6c (Npic_image *np, 
        int rP, int sP, int tP, int zP, int yP, int xP, 
        int rQ, int sQ, int tQ, int zQ, int yQ, int xQ, 
        Npic_c val1)
{
    Npic_image_6c *p1 = NpicCastImage(np);
    int r, s, t, z, y, x;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_6C) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    if (sP > sQ) { int k = sP; sP = sQ; sQ = k; }
    if (rP > rQ) { int k = rP; rP = rQ; rQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (zP < 0) zP = 0; if (zP >= np->gen.zmax) zP = np->gen.zmax-1;
    if (tP < 0) tP = 0; if (tP >= np->gen.tmax) tP = np->gen.tmax-1;
    if (sP < 0) sP = 0; if (sP >= np->gen.smax) sP = np->gen.smax-1;
    if (rP < 0) rP = 0; if (rP >= np->gen.rmax) rP = np->gen.rmax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;
    if (zQ < 0) zQ = 0; if (zQ >= np->gen.zmax) zQ = np->gen.zmax-1;
    if (tQ < 0) tQ = 0; if (tQ >= np->gen.tmax) tQ = np->gen.tmax-1;
    if (sQ < 0) sQ = 0; if (sQ >= np->gen.smax) sQ = np->gen.smax-1;
    if (rQ < 0) rQ = 0; if (rQ >= np->gen.rmax) rQ = np->gen.rmax-1;

    for (r = rP; r <= rQ; r++)
    for (s = sP; s <= sQ; s++)
    for (t = tP; t <= tQ; t++)
    for (z = zP; z <= zQ; z++)
    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[r][s][t][z][y][x] = val1;
}

void NpicDrawRect_6l (Npic_image *np, 
        int rP, int sP, int tP, int zP, int yP, int xP, 
        int rQ, int sQ, int tQ, int zQ, int yQ, int xQ, 
        Npic_l val1)
{
    Npic_image_6l *p1 = NpicCastImage(np);
    int r, s, t, z, y, x;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_6L) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    if (sP > sQ) { int k = sP; sP = sQ; sQ = k; }
    if (rP > rQ) { int k = rP; rP = rQ; rQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (zP < 0) zP = 0; if (zP >= np->gen.zmax) zP = np->gen.zmax-1;
    if (tP < 0) tP = 0; if (tP >= np->gen.tmax) tP = np->gen.tmax-1;
    if (sP < 0) sP = 0; if (sP >= np->gen.smax) sP = np->gen.smax-1;
    if (rP < 0) rP = 0; if (rP >= np->gen.rmax) rP = np->gen.rmax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;
    if (zQ < 0) zQ = 0; if (zQ >= np->gen.zmax) zQ = np->gen.zmax-1;
    if (tQ < 0) tQ = 0; if (tQ >= np->gen.tmax) tQ = np->gen.tmax-1;
    if (sQ < 0) sQ = 0; if (sQ >= np->gen.smax) sQ = np->gen.smax-1;
    if (rQ < 0) rQ = 0; if (rQ >= np->gen.rmax) rQ = np->gen.rmax-1;

    for (r = rP; r <= rQ; r++)
    for (s = sP; s <= sQ; s++)
    for (t = tP; t <= tQ; t++)
    for (z = zP; z <= zQ; z++)
    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[r][s][t][z][y][x] = val1;
}

void NpicDrawRect_6d (Npic_image *np, 
        int rP, int sP, int tP, int zP, int yP, int xP, 
        int rQ, int sQ, int tQ, int zQ, int yQ, int xQ, 
        Npic_d val1)
{
    Npic_image_6d *p1 = NpicCastImage(np);
    int r, s, t, z, y, x;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_6D) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    if (sP > sQ) { int k = sP; sP = sQ; sQ = k; }
    if (rP > rQ) { int k = rP; rP = rQ; rQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (zP < 0) zP = 0; if (zP >= np->gen.zmax) zP = np->gen.zmax-1;
    if (tP < 0) tP = 0; if (tP >= np->gen.tmax) tP = np->gen.tmax-1;
    if (sP < 0) sP = 0; if (sP >= np->gen.smax) sP = np->gen.smax-1;
    if (rP < 0) rP = 0; if (rP >= np->gen.rmax) rP = np->gen.rmax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;
    if (zQ < 0) zQ = 0; if (zQ >= np->gen.zmax) zQ = np->gen.zmax-1;
    if (tQ < 0) tQ = 0; if (tQ >= np->gen.tmax) tQ = np->gen.tmax-1;
    if (sQ < 0) sQ = 0; if (sQ >= np->gen.smax) sQ = np->gen.smax-1;
    if (rQ < 0) rQ = 0; if (rQ >= np->gen.rmax) rQ = np->gen.rmax-1;

    for (r = rP; r <= rQ; r++)
    for (s = sP; s <= sQ; s++)
    for (t = tP; t <= tQ; t++)
    for (z = zP; z <= zQ; z++)
    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[r][s][t][z][y][x] = val1;
}

void NpicDrawRect_2q (Npic_image *np, 
        int yP, int xP, 
        int yQ, int xQ, 
        int a1, int b1, int c1, int d1)
{
    Npic_image_2q *p1 = NpicCastImage(np);
    int y, x;
    Npic_q val1;
    val1.a = a1; val1.b = b1; val1.c = c1; val1.d = d1;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_2Q) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;

    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[y][x] = val1;
}

void NpicDrawRect_3q (Npic_image *np, 
        int zP, int yP, int xP, 
        int zQ, int yQ, int xQ, 
        int a1, int b1, int c1, int d1)
{
    Npic_image_3q *p1 = NpicCastImage(np);
    int z, y, x;
    Npic_q val1;
    val1.a = a1; val1.b = b1; val1.c = c1; val1.d = d1;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_3Q) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (zP < 0) zP = 0; if (zP >= np->gen.zmax) zP = np->gen.zmax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;
    if (zQ < 0) zQ = 0; if (zQ >= np->gen.zmax) zQ = np->gen.zmax-1;

    for (z = zP; z <= zQ; z++)
    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[z][y][x] = val1;
}

void NpicDrawRect_4q (Npic_image *np, 
        int tP, int zP, int yP, int xP, 
        int tQ, int zQ, int yQ, int xQ, 
        int a1, int b1, int c1, int d1)
{
    Npic_image_4q *p1 = NpicCastImage(np);
    int t, z, y, x;
    Npic_q val1;
    val1.a = a1; val1.b = b1; val1.c = c1; val1.d = d1;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_4Q) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (zP < 0) zP = 0; if (zP >= np->gen.zmax) zP = np->gen.zmax-1;
    if (tP < 0) tP = 0; if (tP >= np->gen.tmax) tP = np->gen.tmax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;
    if (zQ < 0) zQ = 0; if (zQ >= np->gen.zmax) zQ = np->gen.zmax-1;
    if (tQ < 0) tQ = 0; if (tQ >= np->gen.tmax) tQ = np->gen.tmax-1;

    for (t = tP; t <= tQ; t++)
    for (z = zP; z <= zQ; z++)
    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[t][z][y][x] = val1;
}

void NpicDrawRect_5q (Npic_image *np, 
        int sP, int tP, int zP, int yP, int xP, 
        int sQ, int tQ, int zQ, int yQ, int xQ, 
        int a1, int b1, int c1, int d1)
{
    Npic_image_5q *p1 = NpicCastImage(np);
    int s, t, z, y, x;
    Npic_q val1;
    val1.a = a1; val1.b = b1; val1.c = c1; val1.d = d1;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_5Q) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    if (sP > sQ) { int k = sP; sP = sQ; sQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (zP < 0) zP = 0; if (zP >= np->gen.zmax) zP = np->gen.zmax-1;
    if (tP < 0) tP = 0; if (tP >= np->gen.tmax) tP = np->gen.tmax-1;
    if (sP < 0) sP = 0; if (sP >= np->gen.smax) sP = np->gen.smax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;
    if (zQ < 0) zQ = 0; if (zQ >= np->gen.zmax) zQ = np->gen.zmax-1;
    if (tQ < 0) tQ = 0; if (tQ >= np->gen.tmax) tQ = np->gen.tmax-1;
    if (sQ < 0) sQ = 0; if (sQ >= np->gen.smax) sQ = np->gen.smax-1;

    for (s = sP; s <= sQ; s++)
    for (t = tP; t <= tQ; t++)
    for (z = zP; z <= zQ; z++)
    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[s][t][z][y][x] = val1;
}

void NpicDrawRect_6q (Npic_image *np, 
        int rP, int sP, int tP, int zP, int yP, int xP, 
        int rQ, int sQ, int tQ, int zQ, int yQ, int xQ, 
        int a1, int b1, int c1, int d1)
{
    Npic_image_6q *p1 = NpicCastImage(np);
    int r, s, t, z, y, x;
    Npic_q val1;
    val1.a = a1; val1.b = b1; val1.c = c1; val1.d = d1;
        
    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_6Q) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }

    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    if (sP > sQ) { int k = sP; sP = sQ; sQ = k; }
    if (rP > rQ) { int k = rP; rP = rQ; rQ = k; }
    
    if (xP < 0) xP = 0; if (xP >= np->gen.xmax) xP = np->gen.xmax-1;
    if (yP < 0) yP = 0; if (yP >= np->gen.ymax) yP = np->gen.ymax-1;
    if (zP < 0) zP = 0; if (zP >= np->gen.zmax) zP = np->gen.zmax-1;
    if (tP < 0) tP = 0; if (tP >= np->gen.tmax) tP = np->gen.tmax-1;
    if (sP < 0) sP = 0; if (sP >= np->gen.smax) sP = np->gen.smax-1;
    if (rP < 0) rP = 0; if (rP >= np->gen.rmax) rP = np->gen.rmax-1;
    if (xQ < 0) xQ = 0; if (xQ >= np->gen.xmax) xQ = np->gen.xmax-1;
    if (yQ < 0) yQ = 0; if (yQ >= np->gen.ymax) yQ = np->gen.ymax-1;
    if (zQ < 0) zQ = 0; if (zQ >= np->gen.zmax) zQ = np->gen.zmax-1;
    if (tQ < 0) tQ = 0; if (tQ >= np->gen.tmax) tQ = np->gen.tmax-1;
    if (sQ < 0) sQ = 0; if (sQ >= np->gen.smax) sQ = np->gen.smax-1;
    if (rQ < 0) rQ = 0; if (rQ >= np->gen.rmax) rQ = np->gen.rmax-1;

    for (r = rP; r <= rQ; r++)
    for (s = sP; s <= sQ; s++)
    for (t = tP; t <= tQ; t++)
    for (z = zP; z <= zQ; z++)
    for (y = yP; y <= yQ; y++)
    for (x = xP; x <= xQ; x++)
        p1->pix[r][s][t][z][y][x] = val1;
}


/******************************************************************************/

/*
 * Draw an ellipse bounded by P and Q, with pixel value val1.
 * P and Q can be outside image.
 *
 * Do not modify other pixels neither border pixels.
 * Do nothing if np is not ok. set not ok on error. Verbose.
*/

void NpicDrawEllipse_2c (Npic_image *np, 
        int yP, int xP, 
        int yQ, int xQ, 
        Npic_c val1)
{
    Npic_image_2c *p1 = NpicCastImage(np);
    int y, x;
    int yA, xA, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           dx, dy;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_2C) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
        
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        if (dx*dx + dy*dy <= 1.0001)
            p1->pix[y][x] = val1;
    }
}

void NpicDrawEllipse_2l (Npic_image *np, 
        int yP, int xP, 
        int yQ, int xQ, 
        Npic_l val1)
{
    Npic_image_2l *p1 = NpicCastImage(np);
    int y, x;
    int yA, xA, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           dx, dy;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_2L) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
        
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        if (dx*dx + dy*dy <= 1.0001)
            p1->pix[y][x] = val1;
    }
}

void NpicDrawEllipse_2d (Npic_image *np, 
        int yP, int xP, 
        int yQ, int xQ, 
        Npic_d val1)
{
    Npic_image_2d *p1 = NpicCastImage(np);
    int y, x;
    int yA, xA, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           dx, dy;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_2D) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
        
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        if (dx*dx + dy*dy <= 1.0001)
            p1->pix[y][x] = val1;
    }
}

void NpicDrawEllipse_3c (Npic_image *np, 
        int zP, int yP, int xP, 
        int zQ, int yQ, int xQ, 
        Npic_c val1)
{
    Npic_image_3c *p1 = NpicCastImage(np);
    int z, y, x;
    int zA, yA, xA, zB, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           zC = (zP+zQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           zR = fabs (zC-zP) + 0.5,
           dx, dy, dz;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_3C) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    zA = zP; if (zA < 0) zA = 0; if (zA >= np->gen.zmax) zA = np->gen.zmax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
    zB = zQ; if (zB < 0) zB = 0; if (zB >= np->gen.zmax) zB = np->gen.zmax-1;
        
    for (z = zA; z <= zB; z++)
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        dz = (zC - z)/zR;
        if (dx*dx + dy*dy + dz*dz <= 1.0001)
            p1->pix[z][y][x] = val1;
    }
}

void NpicDrawEllipse_3l (Npic_image *np, 
        int zP, int yP, int xP, 
        int zQ, int yQ, int xQ, 
        Npic_l val1)
{
    Npic_image_3l *p1 = NpicCastImage(np);
    int z, y, x;
    int zA, yA, xA, zB, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           zC = (zP+zQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           zR = fabs (zC-zP) + 0.5,
           dx, dy, dz;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_3L) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    zA = zP; if (zA < 0) zA = 0; if (zA >= np->gen.zmax) zA = np->gen.zmax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
    zB = zQ; if (zB < 0) zB = 0; if (zB >= np->gen.zmax) zB = np->gen.zmax-1;
        
    for (z = zA; z <= zB; z++)
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        dz = (zC - z)/zR;
        if (dx*dx + dy*dy + dz*dz <= 1.0001)
            p1->pix[z][y][x] = val1;
    }
}

void NpicDrawEllipse_3d (Npic_image *np, 
        int zP, int yP, int xP, 
        int zQ, int yQ, int xQ, 
        Npic_d val1)
{
    Npic_image_3d *p1 = NpicCastImage(np);
    int z, y, x;
    int zA, yA, xA, zB, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           zC = (zP+zQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           zR = fabs (zC-zP) + 0.5,
           dx, dy, dz;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_3D) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    zA = zP; if (zA < 0) zA = 0; if (zA >= np->gen.zmax) zA = np->gen.zmax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
    zB = zQ; if (zB < 0) zB = 0; if (zB >= np->gen.zmax) zB = np->gen.zmax-1;
        
    for (z = zA; z <= zB; z++)
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        dz = (zC - z)/zR;
        if (dx*dx + dy*dy + dz*dz <= 1.0001)
            p1->pix[z][y][x] = val1;
    }
}

void NpicDrawEllipse_4c (Npic_image *np, 
        int tP, int zP, int yP, int xP, 
        int tQ, int zQ, int yQ, int xQ, 
        Npic_c val1)
{
    Npic_image_4c *p1 = NpicCastImage(np);
    int t, z, y, x;
    int tA, zA, yA, xA, tB, zB, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           zC = (zP+zQ)/2.0, tC = (tP+tQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           zR = fabs (zC-zP) + 0.5, tR = fabs (tC-tP) + 0.5,
           dx, dy, dz, dt;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_4C) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    zA = zP; if (zA < 0) zA = 0; if (zA >= np->gen.zmax) zA = np->gen.zmax-1;
    tA = tP; if (tA < 0) tA = 0; if (tA >= np->gen.tmax) tA = np->gen.tmax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
    zB = zQ; if (zB < 0) zB = 0; if (zB >= np->gen.zmax) zB = np->gen.zmax-1;
    tB = tQ; if (tB < 0) tB = 0; if (tB >= np->gen.tmax) tB = np->gen.tmax-1;
        
    for (t = tA; t <= tB; t++)
    for (z = zA; z <= zB; z++)
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        dz = (zC - z)/zR;
        dt = (tC - t)/tR;
        if (dx*dx + dy*dy + dz*dz + dt*dt <= 1.0001)
            p1->pix[t][z][y][x] = val1;
    }
}

void NpicDrawEllipse_4l (Npic_image *np, 
        int tP, int zP, int yP, int xP, 
        int tQ, int zQ, int yQ, int xQ, 
        Npic_l val1)
{
    Npic_image_4l *p1 = NpicCastImage(np);
    int t, z, y, x;
    int tA, zA, yA, xA, tB, zB, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           zC = (zP+zQ)/2.0, tC = (tP+tQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           zR = fabs (zC-zP) + 0.5, tR = fabs (tC-tP) + 0.5,
           dx, dy, dz, dt;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_4L) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    zA = zP; if (zA < 0) zA = 0; if (zA >= np->gen.zmax) zA = np->gen.zmax-1;
    tA = tP; if (tA < 0) tA = 0; if (tA >= np->gen.tmax) tA = np->gen.tmax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
    zB = zQ; if (zB < 0) zB = 0; if (zB >= np->gen.zmax) zB = np->gen.zmax-1;
    tB = tQ; if (tB < 0) tB = 0; if (tB >= np->gen.tmax) tB = np->gen.tmax-1;
        
    for (t = tA; t <= tB; t++)
    for (z = zA; z <= zB; z++)
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        dz = (zC - z)/zR;
        dt = (tC - t)/tR;
        if (dx*dx + dy*dy + dz*dz + dt*dt <= 1.0001)
            p1->pix[t][z][y][x] = val1;
    }
}

void NpicDrawEllipse_4d (Npic_image *np, 
        int tP, int zP, int yP, int xP, 
        int tQ, int zQ, int yQ, int xQ, 
        Npic_d val1)
{
    Npic_image_4d *p1 = NpicCastImage(np);
    int t, z, y, x;
    int tA, zA, yA, xA, tB, zB, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           zC = (zP+zQ)/2.0, tC = (tP+tQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           zR = fabs (zC-zP) + 0.5, tR = fabs (tC-tP) + 0.5,
           dx, dy, dz, dt;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_4D) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    zA = zP; if (zA < 0) zA = 0; if (zA >= np->gen.zmax) zA = np->gen.zmax-1;
    tA = tP; if (tA < 0) tA = 0; if (tA >= np->gen.tmax) tA = np->gen.tmax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
    zB = zQ; if (zB < 0) zB = 0; if (zB >= np->gen.zmax) zB = np->gen.zmax-1;
    tB = tQ; if (tB < 0) tB = 0; if (tB >= np->gen.tmax) tB = np->gen.tmax-1;
        
    for (t = tA; t <= tB; t++)
    for (z = zA; z <= zB; z++)
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        dz = (zC - z)/zR;
        dt = (tC - t)/tR;
        if (dx*dx + dy*dy + dz*dz + dt*dt <= 1.0001)
            p1->pix[t][z][y][x] = val1;
    }
}

void NpicDrawEllipse_5c (Npic_image *np, 
        int sP, int tP, int zP, int yP, int xP, 
        int sQ, int tQ, int zQ, int yQ, int xQ, 
        Npic_c val1)
{
    Npic_image_5c *p1 = NpicCastImage(np);
    int s, t, z, y, x;
    int sA, tA, zA, yA, xA, sB, tB, zB, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           zC = (zP+zQ)/2.0, tC = (tP+tQ)/2.0,
           sC = (sP+sQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           zR = fabs (zC-zP) + 0.5, tR = fabs (tC-tP) + 0.5,
           sR = fabs (sC-sP) + 0.5,
           dx, dy, dz, dt, ds;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_5C) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    if (sP > sQ) { int k = sP; sP = sQ; sQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    zA = zP; if (zA < 0) zA = 0; if (zA >= np->gen.zmax) zA = np->gen.zmax-1;
    tA = tP; if (tA < 0) tA = 0; if (tA >= np->gen.tmax) tA = np->gen.tmax-1;
    sA = sP; if (sA < 0) sA = 0; if (sA >= np->gen.smax) sA = np->gen.smax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
    zB = zQ; if (zB < 0) zB = 0; if (zB >= np->gen.zmax) zB = np->gen.zmax-1;
    tB = tQ; if (tB < 0) tB = 0; if (tB >= np->gen.tmax) tB = np->gen.tmax-1;
    sB = sQ; if (sB < 0) sB = 0; if (sB >= np->gen.smax) sB = np->gen.smax-1;
        
    for (s = sA; s <= sB; s++)
    for (t = tA; t <= tB; t++)
    for (z = zA; z <= zB; z++)
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        dz = (zC - z)/zR;
        dt = (tC - t)/tR;
        ds = (sC - s)/sR;
        if (dx*dx + dy*dy + dz*dz + dt*dt + ds*ds <= 1.0001)
            p1->pix[s][t][z][y][x] = val1;
    }
}

void NpicDrawEllipse_5l (Npic_image *np, 
        int sP, int tP, int zP, int yP, int xP, 
        int sQ, int tQ, int zQ, int yQ, int xQ, 
        Npic_l val1)
{
    Npic_image_5l *p1 = NpicCastImage(np);
    int s, t, z, y, x;
    int sA, tA, zA, yA, xA, sB, tB, zB, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           zC = (zP+zQ)/2.0, tC = (tP+tQ)/2.0,
           sC = (sP+sQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           zR = fabs (zC-zP) + 0.5, tR = fabs (tC-tP) + 0.5,
           sR = fabs (sC-sP) + 0.5,
           dx, dy, dz, dt, ds;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_5L) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    if (sP > sQ) { int k = sP; sP = sQ; sQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    zA = zP; if (zA < 0) zA = 0; if (zA >= np->gen.zmax) zA = np->gen.zmax-1;
    tA = tP; if (tA < 0) tA = 0; if (tA >= np->gen.tmax) tA = np->gen.tmax-1;
    sA = sP; if (sA < 0) sA = 0; if (sA >= np->gen.smax) sA = np->gen.smax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
    zB = zQ; if (zB < 0) zB = 0; if (zB >= np->gen.zmax) zB = np->gen.zmax-1;
    tB = tQ; if (tB < 0) tB = 0; if (tB >= np->gen.tmax) tB = np->gen.tmax-1;
    sB = sQ; if (sB < 0) sB = 0; if (sB >= np->gen.smax) sB = np->gen.smax-1;
        
    for (s = sA; s <= sB; s++)
    for (t = tA; t <= tB; t++)
    for (z = zA; z <= zB; z++)
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        dz = (zC - z)/zR;
        dt = (tC - t)/tR;
        ds = (sC - s)/sR;
        if (dx*dx + dy*dy + dz*dz + dt*dt + ds*ds <= 1.0001)
            p1->pix[s][t][z][y][x] = val1;
    }
}

void NpicDrawEllipse_5d (Npic_image *np, 
        int sP, int tP, int zP, int yP, int xP, 
        int sQ, int tQ, int zQ, int yQ, int xQ, 
        Npic_d val1)
{
    Npic_image_5d *p1 = NpicCastImage(np);
    int s, t, z, y, x;
    int sA, tA, zA, yA, xA, sB, tB, zB, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           zC = (zP+zQ)/2.0, tC = (tP+tQ)/2.0,
           sC = (sP+sQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           zR = fabs (zC-zP) + 0.5, tR = fabs (tC-tP) + 0.5,
           sR = fabs (sC-sP) + 0.5,
           dx, dy, dz, dt, ds;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_5D) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    if (sP > sQ) { int k = sP; sP = sQ; sQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    zA = zP; if (zA < 0) zA = 0; if (zA >= np->gen.zmax) zA = np->gen.zmax-1;
    tA = tP; if (tA < 0) tA = 0; if (tA >= np->gen.tmax) tA = np->gen.tmax-1;
    sA = sP; if (sA < 0) sA = 0; if (sA >= np->gen.smax) sA = np->gen.smax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
    zB = zQ; if (zB < 0) zB = 0; if (zB >= np->gen.zmax) zB = np->gen.zmax-1;
    tB = tQ; if (tB < 0) tB = 0; if (tB >= np->gen.tmax) tB = np->gen.tmax-1;
    sB = sQ; if (sB < 0) sB = 0; if (sB >= np->gen.smax) sB = np->gen.smax-1;
        
    for (s = sA; s <= sB; s++)
    for (t = tA; t <= tB; t++)
    for (z = zA; z <= zB; z++)
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        dz = (zC - z)/zR;
        dt = (tC - t)/tR;
        ds = (sC - s)/sR;
        if (dx*dx + dy*dy + dz*dz + dt*dt + ds*ds <= 1.0001)
            p1->pix[s][t][z][y][x] = val1;
    }
}

void NpicDrawEllipse_6c (Npic_image *np, 
        int rP, int sP, int tP, int zP, int yP, int xP, 
        int rQ, int sQ, int tQ, int zQ, int yQ, int xQ, 
        Npic_c val1)
{
    Npic_image_6c *p1 = NpicCastImage(np);
    int r, s, t, z, y, x;
    int rA, sA, tA, zA, yA, xA, rB, sB, tB, zB, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           zC = (zP+zQ)/2.0, tC = (tP+tQ)/2.0,
           sC = (sP+sQ)/2.0, rC = (rP+rQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           zR = fabs (zC-zP) + 0.5, tR = fabs (tC-tP) + 0.5,
           sR = fabs (sC-sP) + 0.5, rR = fabs (rC-rP) + 0.5,
           dx, dy, dz, dt, ds, dr;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_6C) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    if (sP > sQ) { int k = sP; sP = sQ; sQ = k; }
    if (rP > rQ) { int k = rP; rP = rQ; rQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    zA = zP; if (zA < 0) zA = 0; if (zA >= np->gen.zmax) zA = np->gen.zmax-1;
    tA = tP; if (tA < 0) tA = 0; if (tA >= np->gen.tmax) tA = np->gen.tmax-1;
    sA = sP; if (sA < 0) sA = 0; if (sA >= np->gen.smax) sA = np->gen.smax-1;
    rA = rP; if (rA < 0) rA = 0; if (rA >= np->gen.rmax) rA = np->gen.rmax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
    zB = zQ; if (zB < 0) zB = 0; if (zB >= np->gen.zmax) zB = np->gen.zmax-1;
    tB = tQ; if (tB < 0) tB = 0; if (tB >= np->gen.tmax) tB = np->gen.tmax-1;
    sB = sQ; if (sB < 0) sB = 0; if (sB >= np->gen.smax) sB = np->gen.smax-1;
    rB = rQ; if (rB < 0) rB = 0; if (rB >= np->gen.rmax) rB = np->gen.rmax-1;
        
    for (r = rA; r <= rB; r++)
    for (s = sA; s <= sB; s++)
    for (t = tA; t <= tB; t++)
    for (z = zA; z <= zB; z++)
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        dz = (zC - z)/zR;
        dt = (tC - t)/tR;
        ds = (sC - s)/sR;
        dr = (rC - r)/rR;
        if (dx*dx + dy*dy + dz*dz + dt*dt + ds*ds + dr*dr <= 1.0001)
            p1->pix[r][s][t][z][y][x] = val1;
    }
}

void NpicDrawEllipse_6l (Npic_image *np, 
        int rP, int sP, int tP, int zP, int yP, int xP, 
        int rQ, int sQ, int tQ, int zQ, int yQ, int xQ, 
        Npic_l val1)
{
    Npic_image_6l *p1 = NpicCastImage(np);
    int r, s, t, z, y, x;
    int rA, sA, tA, zA, yA, xA, rB, sB, tB, zB, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           zC = (zP+zQ)/2.0, tC = (tP+tQ)/2.0,
           sC = (sP+sQ)/2.0, rC = (rP+rQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           zR = fabs (zC-zP) + 0.5, tR = fabs (tC-tP) + 0.5,
           sR = fabs (sC-sP) + 0.5, rR = fabs (rC-rP) + 0.5,
           dx, dy, dz, dt, ds, dr;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_6L) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    if (sP > sQ) { int k = sP; sP = sQ; sQ = k; }
    if (rP > rQ) { int k = rP; rP = rQ; rQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    zA = zP; if (zA < 0) zA = 0; if (zA >= np->gen.zmax) zA = np->gen.zmax-1;
    tA = tP; if (tA < 0) tA = 0; if (tA >= np->gen.tmax) tA = np->gen.tmax-1;
    sA = sP; if (sA < 0) sA = 0; if (sA >= np->gen.smax) sA = np->gen.smax-1;
    rA = rP; if (rA < 0) rA = 0; if (rA >= np->gen.rmax) rA = np->gen.rmax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
    zB = zQ; if (zB < 0) zB = 0; if (zB >= np->gen.zmax) zB = np->gen.zmax-1;
    tB = tQ; if (tB < 0) tB = 0; if (tB >= np->gen.tmax) tB = np->gen.tmax-1;
    sB = sQ; if (sB < 0) sB = 0; if (sB >= np->gen.smax) sB = np->gen.smax-1;
    rB = rQ; if (rB < 0) rB = 0; if (rB >= np->gen.rmax) rB = np->gen.rmax-1;
        
    for (r = rA; r <= rB; r++)
    for (s = sA; s <= sB; s++)
    for (t = tA; t <= tB; t++)
    for (z = zA; z <= zB; z++)
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        dz = (zC - z)/zR;
        dt = (tC - t)/tR;
        ds = (sC - s)/sR;
        dr = (rC - r)/rR;
        if (dx*dx + dy*dy + dz*dz + dt*dt + ds*ds + dr*dr <= 1.0001)
            p1->pix[r][s][t][z][y][x] = val1;
    }
}

void NpicDrawEllipse_6d (Npic_image *np, 
        int rP, int sP, int tP, int zP, int yP, int xP, 
        int rQ, int sQ, int tQ, int zQ, int yQ, int xQ, 
        Npic_d val1)
{
    Npic_image_6d *p1 = NpicCastImage(np);
    int r, s, t, z, y, x;
    int rA, sA, tA, zA, yA, xA, rB, sB, tB, zB, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           zC = (zP+zQ)/2.0, tC = (tP+tQ)/2.0,
           sC = (sP+sQ)/2.0, rC = (rP+rQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           zR = fabs (zC-zP) + 0.5, tR = fabs (tC-tP) + 0.5,
           sR = fabs (sC-sP) + 0.5, rR = fabs (rC-rP) + 0.5,
           dx, dy, dz, dt, ds, dr;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_6D) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    if (sP > sQ) { int k = sP; sP = sQ; sQ = k; }
    if (rP > rQ) { int k = rP; rP = rQ; rQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    zA = zP; if (zA < 0) zA = 0; if (zA >= np->gen.zmax) zA = np->gen.zmax-1;
    tA = tP; if (tA < 0) tA = 0; if (tA >= np->gen.tmax) tA = np->gen.tmax-1;
    sA = sP; if (sA < 0) sA = 0; if (sA >= np->gen.smax) sA = np->gen.smax-1;
    rA = rP; if (rA < 0) rA = 0; if (rA >= np->gen.rmax) rA = np->gen.rmax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
    zB = zQ; if (zB < 0) zB = 0; if (zB >= np->gen.zmax) zB = np->gen.zmax-1;
    tB = tQ; if (tB < 0) tB = 0; if (tB >= np->gen.tmax) tB = np->gen.tmax-1;
    sB = sQ; if (sB < 0) sB = 0; if (sB >= np->gen.smax) sB = np->gen.smax-1;
    rB = rQ; if (rB < 0) rB = 0; if (rB >= np->gen.rmax) rB = np->gen.rmax-1;
        
    for (r = rA; r <= rB; r++)
    for (s = sA; s <= sB; s++)
    for (t = tA; t <= tB; t++)
    for (z = zA; z <= zB; z++)
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        dz = (zC - z)/zR;
        dt = (tC - t)/tR;
        ds = (sC - s)/sR;
        dr = (rC - r)/rR;
        if (dx*dx + dy*dy + dz*dz + dt*dt + ds*ds + dr*dr <= 1.0001)
            p1->pix[r][s][t][z][y][x] = val1;
    }
}

void NpicDrawEllipse_2q (Npic_image *np, 
        int yP, int xP, 
        int yQ, int xQ, 
        int a1, int b1, int c1, int d1)
{
    Npic_image_2q *p1 = NpicCastImage(np);
    int y, x;
    int yA, xA, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           dx, dy;
    Npic_q val1;
    val1.a = a1; val1.b = b1; val1.c = c1; val1.d = d1;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_2Q) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
        
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        if (dx*dx + dy*dy <= 1.0001)
            p1->pix[y][x] = val1;
    }
}

void NpicDrawEllipse_3q (Npic_image *np, 
        int zP, int yP, int xP, 
        int zQ, int yQ, int xQ, 
        int a1, int b1, int c1, int d1)
{
    Npic_image_3q *p1 = NpicCastImage(np);
    int z, y, x;
    int zA, yA, xA, zB, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           zC = (zP+zQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           zR = fabs (zC-zP) + 0.5,
           dx, dy, dz;
    Npic_q val1;
    val1.a = a1; val1.b = b1; val1.c = c1; val1.d = d1;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_3Q) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    zA = zP; if (zA < 0) zA = 0; if (zA >= np->gen.zmax) zA = np->gen.zmax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
    zB = zQ; if (zB < 0) zB = 0; if (zB >= np->gen.zmax) zB = np->gen.zmax-1;
        
    for (z = zA; z <= zB; z++)
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        dz = (zC - z)/zR;
        if (dx*dx + dy*dy + dz*dz <= 1.0001)
            p1->pix[z][y][x] = val1;
    }
}

void NpicDrawEllipse_4q (Npic_image *np, 
        int tP, int zP, int yP, int xP, 
        int tQ, int zQ, int yQ, int xQ, 
        int a1, int b1, int c1, int d1)
{
    Npic_image_4q *p1 = NpicCastImage(np);
    int t, z, y, x;
    int tA, zA, yA, xA, tB, zB, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           zC = (zP+zQ)/2.0, tC = (tP+tQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           zR = fabs (zC-zP) + 0.5, tR = fabs (tC-tP) + 0.5,
           dx, dy, dz, dt;
    Npic_q val1;
    val1.a = a1; val1.b = b1; val1.c = c1; val1.d = d1;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_4Q) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    zA = zP; if (zA < 0) zA = 0; if (zA >= np->gen.zmax) zA = np->gen.zmax-1;
    tA = tP; if (tA < 0) tA = 0; if (tA >= np->gen.tmax) tA = np->gen.tmax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
    zB = zQ; if (zB < 0) zB = 0; if (zB >= np->gen.zmax) zB = np->gen.zmax-1;
    tB = tQ; if (tB < 0) tB = 0; if (tB >= np->gen.tmax) tB = np->gen.tmax-1;
        
    for (t = tA; t <= tB; t++)
    for (z = zA; z <= zB; z++)
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        dz = (zC - z)/zR;
        dt = (tC - t)/tR;
        if (dx*dx + dy*dy + dz*dz + dt*dt <= 1.0001)
            p1->pix[t][z][y][x] = val1;
    }
}

void NpicDrawEllipse_5q (Npic_image *np, 
        int sP, int tP, int zP, int yP, int xP, 
        int sQ, int tQ, int zQ, int yQ, int xQ, 
        int a1, int b1, int c1, int d1)
{
    Npic_image_5q *p1 = NpicCastImage(np);
    int s, t, z, y, x;
    int sA, tA, zA, yA, xA, sB, tB, zB, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           zC = (zP+zQ)/2.0, tC = (tP+tQ)/2.0,
           sC = (sP+sQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           zR = fabs (zC-zP) + 0.5, tR = fabs (tC-tP) + 0.5,
           sR = fabs (sC-sP) + 0.5,
           dx, dy, dz, dt, ds;
    Npic_q val1;
    val1.a = a1; val1.b = b1; val1.c = c1; val1.d = d1;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_5Q) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    if (sP > sQ) { int k = sP; sP = sQ; sQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    zA = zP; if (zA < 0) zA = 0; if (zA >= np->gen.zmax) zA = np->gen.zmax-1;
    tA = tP; if (tA < 0) tA = 0; if (tA >= np->gen.tmax) tA = np->gen.tmax-1;
    sA = sP; if (sA < 0) sA = 0; if (sA >= np->gen.smax) sA = np->gen.smax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
    zB = zQ; if (zB < 0) zB = 0; if (zB >= np->gen.zmax) zB = np->gen.zmax-1;
    tB = tQ; if (tB < 0) tB = 0; if (tB >= np->gen.tmax) tB = np->gen.tmax-1;
    sB = sQ; if (sB < 0) sB = 0; if (sB >= np->gen.smax) sB = np->gen.smax-1;
        
    for (s = sA; s <= sB; s++)
    for (t = tA; t <= tB; t++)
    for (z = zA; z <= zB; z++)
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        dz = (zC - z)/zR;
        dt = (tC - t)/tR;
        ds = (sC - s)/sR;
        if (dx*dx + dy*dy + dz*dz + dt*dt + ds*ds <= 1.0001)
            p1->pix[s][t][z][y][x] = val1;
    }
}

void NpicDrawEllipse_6q (Npic_image *np, 
        int rP, int sP, int tP, int zP, int yP, int xP, 
        int rQ, int sQ, int tQ, int zQ, int yQ, int xQ, 
        int a1, int b1, int c1, int d1)
{
    Npic_image_6q *p1 = NpicCastImage(np);
    int r, s, t, z, y, x;
    int rA, sA, tA, zA, yA, xA, rB, sB, tB, zB, yB, xB;
    double xC = (xP+xQ)/2.0, yC = (yP+yQ)/2.0,
           zC = (zP+zQ)/2.0, tC = (tP+tQ)/2.0,
           sC = (sP+sQ)/2.0, rC = (rP+rQ)/2.0,
           xR = fabs (xC-xP) + 0.5, yR = fabs (yC-yP) + 0.5, 
           zR = fabs (zC-zP) + 0.5, tR = fabs (tC-tP) + 0.5,
           sR = fabs (sC-sP) + 0.5, rR = fabs (rC-rP) + 0.5,
           dx, dy, dz, dt, ds, dr;
    Npic_q val1;
    val1.a = a1; val1.b = b1; val1.c = c1; val1.d = d1;

    if (NpicImageIsOK (np, __func__) != NPIC_SUCCESS) return;
    
    if (np->type != NPIC_IMAGE_6Q) {
        np->gen.ok = NpicError (__func__, NPIC_ERR_UNEX_NPIC, "");
        return;
    }
    
    if (xP > xQ) { int k = xP; xP = xQ; xQ = k; }
    if (yP > yQ) { int k = yP; yP = yQ; yQ = k; }
    if (zP > zQ) { int k = zP; zP = zQ; zQ = k; }
    if (tP > tQ) { int k = tP; tP = tQ; tQ = k; }
    if (sP > sQ) { int k = sP; sP = sQ; sQ = k; }
    if (rP > rQ) { int k = rP; rP = rQ; rQ = k; }
    
    xA = xP; if (xA < 0) xA = 0; if (xA >= np->gen.xmax) xA = np->gen.xmax-1;
    yA = yP; if (yA < 0) yA = 0; if (yA >= np->gen.ymax) yA = np->gen.ymax-1;
    zA = zP; if (zA < 0) zA = 0; if (zA >= np->gen.zmax) zA = np->gen.zmax-1;
    tA = tP; if (tA < 0) tA = 0; if (tA >= np->gen.tmax) tA = np->gen.tmax-1;
    sA = sP; if (sA < 0) sA = 0; if (sA >= np->gen.smax) sA = np->gen.smax-1;
    rA = rP; if (rA < 0) rA = 0; if (rA >= np->gen.rmax) rA = np->gen.rmax-1;
    xB = xQ; if (xB < 0) xB = 0; if (xB >= np->gen.xmax) xB = np->gen.xmax-1;
    yB = yQ; if (yB < 0) yB = 0; if (yB >= np->gen.ymax) yB = np->gen.ymax-1;
    zB = zQ; if (zB < 0) zB = 0; if (zB >= np->gen.zmax) zB = np->gen.zmax-1;
    tB = tQ; if (tB < 0) tB = 0; if (tB >= np->gen.tmax) tB = np->gen.tmax-1;
    sB = sQ; if (sB < 0) sB = 0; if (sB >= np->gen.smax) sB = np->gen.smax-1;
    rB = rQ; if (rB < 0) rB = 0; if (rB >= np->gen.rmax) rB = np->gen.rmax-1;
        
    for (r = rA; r <= rB; r++)
    for (s = sA; s <= sB; s++)
    for (t = tA; t <= tB; t++)
    for (z = zA; z <= zB; z++)
    for (y = yA; y <= yB; y++)
    for (x = xA; x <= xB; x++)
    {
        dx = (xC - x)/xR;
        dy = (yC - y)/yR;
        dz = (zC - z)/zR;
        dt = (tC - t)/tR;
        ds = (sC - s)/sR;
        dr = (rC - r)/rR;
        if (dx*dx + dy*dy + dz*dz + dt*dt + ds*ds + dr*dr <= 1.0001)
            p1->pix[r][s][t][z][y][x] = val1;
    }
}


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