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

/*
 * mask_comp.c - 25/11/2008
 *
 * Some computations on masks
*/


#include <npic.h>


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

/*
 * Create and compute the half mask mh corresponding to the mask generator mg,
 * by inserting all the G-symmetrical vectors of mg which are in the
 * half space in scan line order "for r, for s, for t, for z, for y, for x".
 * Do nothing if mg is not ok.
 * Do not copy text properties; for that, use NpicMaskCopyProps.
 * Return the new mask mh on success, else return NULL. Verbose.
*/

Npic_mask *NpicCompHalfMask (Npic_mask *mg)
{
    return NpicCompSymsMask (mg, 1, __func__);
}

/* The same for full mask. */

Npic_mask *NpicCompFullMask (Npic_mask *mg)
{
    return NpicCompSymsMask (mg, 0, __func__);
}


/*
 * Create and compute the generator mask mg corresponding to the half
 * or full mask mh. Assume mh is G-symmetric.
 * Do nothing if mh is not ok.
 * Do not copy text properties; for that, use NpicMaskCopyProps.
 * Return the new mask mg on success, else return NULL. Verbose.
*/

Npic_mask *NpicCompGeneMask (Npic_mask *mh)
{
    int i;
    Npic_mask *mg;
    
    if (NpicMaskIsOK (mh, __func__) != NPIC_SUCCESS)
        return NULL;

    mg = NpicCreateMask (mh->type);
    if (mg == NULL) return NULL;

    switch (mh->type)
    {        
        case NPIC_MASK_2L : 
        {
            Npic_mask_2l *dmh = NpicCastMask (mh);

            for (i = 0; i < dmh->nb; i++)
            {
                if ( 0 <= dmh->v[i].y && dmh->v[i].y <= dmh->v[i].x )
                    NpicMaskInsert_2l (mg, 
                        dmh->v[i].y, dmh->v[i].x, dmh->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_2D : 
        {
            Npic_mask_2d *dmh = NpicCastMask (mh);

            for (i = 0; i < dmh->nb; i++)
            {
                if ( 0 <= dmh->v[i].y && dmh->v[i].y <= dmh->v[i].x )
                    NpicMaskInsert_2d (mg, 
                        dmh->v[i].y, dmh->v[i].x, dmh->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_3L : 
        {
            Npic_mask_3l *dmh = NpicCastMask (mh);

            for (i = 0; i < dmh->nb; i++)
            {
                if ( 0 <= dmh->v[i].z && 
                     dmh->v[i].z <= dmh->v[i].y && dmh->v[i].y <= dmh->v[i].x )
                    NpicMaskInsert_3l (mg, 
                        dmh->v[i].z,
                        dmh->v[i].y, dmh->v[i].x, dmh->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_3D : 
        {
            Npic_mask_3d *dmh = NpicCastMask (mh);

            for (i = 0; i < dmh->nb; i++)
            {
                if ( 0 <= dmh->v[i].z && 
                     dmh->v[i].z <= dmh->v[i].y && dmh->v[i].y <= dmh->v[i].x )
                    NpicMaskInsert_3d (mg, 
                        dmh->v[i].z,
                        dmh->v[i].y, dmh->v[i].x, dmh->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_4L : 
        {
            Npic_mask_4l *dmh = NpicCastMask (mh);

            for (i = 0; i < dmh->nb; i++)
            {
                if ( 0 <= dmh->v[i].t && dmh->v[i].t <= dmh->v[i].z && 
                     dmh->v[i].z <= dmh->v[i].y && dmh->v[i].y <= dmh->v[i].x )
                    NpicMaskInsert_4l (mg, 
                        dmh->v[i].t, dmh->v[i].z,
                        dmh->v[i].y, dmh->v[i].x, dmh->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_4D : 
        {
            Npic_mask_4d *dmh = NpicCastMask (mh);

            for (i = 0; i < dmh->nb; i++)
            {
                if ( 0 <= dmh->v[i].t && dmh->v[i].t <= dmh->v[i].z && 
                     dmh->v[i].z <= dmh->v[i].y && dmh->v[i].y <= dmh->v[i].x )
                    NpicMaskInsert_4d (mg, 
                        dmh->v[i].t, dmh->v[i].z,
                        dmh->v[i].y, dmh->v[i].x, dmh->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_5L : 
        {
            Npic_mask_5l *dmh = NpicCastMask (mh);

            for (i = 0; i < dmh->nb; i++)
            {
                if ( 0 <= dmh->v[i].s && 
                     dmh->v[i].s <= dmh->v[i].t && dmh->v[i].t <= dmh->v[i].z && 
                     dmh->v[i].z <= dmh->v[i].y && dmh->v[i].y <= dmh->v[i].x )
                    NpicMaskInsert_5l (mg, dmh->v[i].s, 
                        dmh->v[i].t, dmh->v[i].z,
                        dmh->v[i].y, dmh->v[i].x, dmh->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_5D : 
        {
            Npic_mask_5d *dmh = NpicCastMask (mh);

            for (i = 0; i < dmh->nb; i++)
            {
                if ( 0 <= dmh->v[i].s && 
                     dmh->v[i].s <= dmh->v[i].t && dmh->v[i].t <= dmh->v[i].z && 
                     dmh->v[i].z <= dmh->v[i].y && dmh->v[i].y <= dmh->v[i].x )
                    NpicMaskInsert_5d (mg, dmh->v[i].s, 
                        dmh->v[i].t, dmh->v[i].z,
                        dmh->v[i].y, dmh->v[i].x, dmh->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_6L : 
        {
            Npic_mask_6l *dmh = NpicCastMask (mh);

            for (i = 0; i < dmh->nb; i++)
            {
                if ( 0 <= dmh->v[i].r && dmh->v[i].r <= dmh->v[i].s && 
                     dmh->v[i].s <= dmh->v[i].t && dmh->v[i].t <= dmh->v[i].z && 
                     dmh->v[i].z <= dmh->v[i].y && dmh->v[i].y <= dmh->v[i].x )
                    NpicMaskInsert_6l (mg, dmh->v[i].r, dmh->v[i].s, 
                        dmh->v[i].t, dmh->v[i].z,
                        dmh->v[i].y, dmh->v[i].x, dmh->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_6D : 
        {
            Npic_mask_6d *dmh = NpicCastMask (mh);

            for (i = 0; i < dmh->nb; i++)
            {
                if ( 0 <= dmh->v[i].r && dmh->v[i].r <= dmh->v[i].s && 
                     dmh->v[i].s <= dmh->v[i].t && dmh->v[i].t <= dmh->v[i].z && 
                     dmh->v[i].z <= dmh->v[i].y && dmh->v[i].y <= dmh->v[i].x )
                    NpicMaskInsert_6d (mg, dmh->v[i].r, dmh->v[i].s, 
                        dmh->v[i].t, dmh->v[i].z,
                        dmh->v[i].y, dmh->v[i].x, dmh->v[i].h);
             }
            break;
        }
              
        default : {
            NpicError (__func__, NPIC_ERR_UNEX_TYPE, "");
            NpicDestroyMask (mg);
            return NULL;
        }
    }
    
    if (mg->gen.ok != NPIC_SUCCESS) { NpicDestroyMask (mg); mg = NULL; }
    return mg;
}


/*
 * Compute the largest coordinate r of the mask (even if m is not ok).
 * Return r on success, else return 0. Silent.
*/

int NpicMaskLargestCoord (Npic_mask *m)
{
    int i, j = 0, k;
            
    if (m == NULL) return 0;
    
    switch (m->type)
    {        
        case NPIC_MASK_2L:
        {
            Npic_mask_2l *dm = NpicCastMask (m);

            for (i = 0; i < dm->nb; i++)
            {
                k = abs(dm->v[i].y); if (j < k) j = k;
                k = abs(dm->v[i].x); if (j < k) j = k;
            }
            
            return j;
        }
        
        case NPIC_MASK_2D:
        {
            Npic_mask_2d *dm = NpicCastMask (m);

            for (i = 0; i < dm->nb; i++)
            {
                k = abs(dm->v[i].y); if (j < k) j = k;
                k = abs(dm->v[i].x); if (j < k) j = k;
            }
            
            return j;
        }
        
        case NPIC_MASK_3L:
        {
            Npic_mask_3l *dm = NpicCastMask (m);

            for (i = 0; i < dm->nb; i++)
            {
                k = abs(dm->v[i].z); if (j < k) j = k;
                k = abs(dm->v[i].y); if (j < k) j = k;
                k = abs(dm->v[i].x); if (j < k) j = k;
            }
            
            return j;
        }
        
        case NPIC_MASK_3D:
        {
            Npic_mask_3d *dm = NpicCastMask (m);

            for (i = 0; i < dm->nb; i++)
            {
                k = abs(dm->v[i].z); if (j < k) j = k;
                k = abs(dm->v[i].y); if (j < k) j = k;
                k = abs(dm->v[i].x); if (j < k) j = k;
            }
            
            return j;
        }
        
        case NPIC_MASK_4L:
        {
            Npic_mask_4l *dm = NpicCastMask (m);

            for (i = 0; i < dm->nb; i++)
            {
                k = abs(dm->v[i].t); if (j < k) j = k;
                k = abs(dm->v[i].z); if (j < k) j = k;
                k = abs(dm->v[i].y); if (j < k) j = k;
                k = abs(dm->v[i].x); if (j < k) j = k;
            }
            
            return j;
        }
        
        case NPIC_MASK_4D:
        {
            Npic_mask_4d *dm = NpicCastMask (m);

            for (i = 0; i < dm->nb; i++)
            {
                k = abs(dm->v[i].t); if (j < k) j = k;
                k = abs(dm->v[i].z); if (j < k) j = k;
                k = abs(dm->v[i].y); if (j < k) j = k;
                k = abs(dm->v[i].x); if (j < k) j = k;
            }
            
            return j;
        }
        
        case NPIC_MASK_5L:
        {
            Npic_mask_5l *dm = NpicCastMask (m);

            for (i = 0; i < dm->nb; i++)
            {
                k = abs(dm->v[i].s); if (j < k) j = k;
                k = abs(dm->v[i].t); if (j < k) j = k;
                k = abs(dm->v[i].z); if (j < k) j = k;
                k = abs(dm->v[i].y); if (j < k) j = k;
                k = abs(dm->v[i].x); if (j < k) j = k;
            }
            
            return j;
        }
        
        case NPIC_MASK_5D:
        {
            Npic_mask_5d *dm = NpicCastMask (m);

            for (i = 0; i < dm->nb; i++)
            {
                k = abs(dm->v[i].s); if (j < k) j = k;
                k = abs(dm->v[i].t); if (j < k) j = k;
                k = abs(dm->v[i].z); if (j < k) j = k;
                k = abs(dm->v[i].y); if (j < k) j = k;
                k = abs(dm->v[i].x); if (j < k) j = k;
            }
            
            return j;
        }
        
        case NPIC_MASK_6L:
        {
            Npic_mask_6l *dm = NpicCastMask (m);

            for (i = 0; i < dm->nb; i++)
            {
                k = abs(dm->v[i].r); if (j < k) j = k;
                k = abs(dm->v[i].s); if (j < k) j = k;
                k = abs(dm->v[i].t); if (j < k) j = k;
                k = abs(dm->v[i].z); if (j < k) j = k;
                k = abs(dm->v[i].y); if (j < k) j = k;
                k = abs(dm->v[i].x); if (j < k) j = k;
            }
            
            return j;
        }
        
        case NPIC_MASK_6D:
        {
            Npic_mask_6d *dm = NpicCastMask (m);

            for (i = 0; i < dm->nb; i++)
            {
                k = abs(dm->v[i].r); if (j < k) j = k;
                k = abs(dm->v[i].s); if (j < k) j = k;
                k = abs(dm->v[i].t); if (j < k) j = k;
                k = abs(dm->v[i].z); if (j < k) j = k;
                k = abs(dm->v[i].y); if (j < k) j = k;
                k = abs(dm->v[i].x); if (j < k) j = k;
            }
            
            return j;
        }
        
        default: return 0;
    }
}


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

/*
 * Compute half or full mask by G-symmetries.
 * Return new mask or NULL.
*/

Npic_mask *NpicCompSymsMask (Npic_mask *mg, int half, const char *funcname)
{
    int i;
    Npic_gsym gs;
    Npic_mask *mh;
    
    if (NpicMaskIsOK (mg, funcname) != NPIC_SUCCESS)
        return NULL;

    mh = NpicCreateMask (mg->type);
    if (mh == NULL) return NULL;

    switch (mg->type)
    {        
        case NPIC_MASK_2L : 
        {
            Npic_mask_2l *dmg = NpicCastMask (mg);

            for (i = 0; i < dmg->nb; i++)
            {
                gs.x[1] = dmg->v[i].x;
                gs.x[2] = dmg->v[i].y;
                gs.dim = 2;
                gs.half = half;  /* half or full mask */
                
                NpicGsymInit (&gs);
                while (NpicGsymNext (&gs) && mh->gen.ok == NPIC_SUCCESS)
                    NpicMaskInsert_2l (mh, 
                            gs.x[2], gs.x[1], dmg->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_2D : 
        {
            Npic_mask_2d *dmg = NpicCastMask (mg);

            for (i = 0; i < dmg->nb; i++)
            {
                gs.x[1] = dmg->v[i].x;
                gs.x[2] = dmg->v[i].y;
                gs.dim = 2;
                gs.half = half;  /* half or full mask */
                
                NpicGsymInit (&gs);
                while (NpicGsymNext (&gs) && mh->gen.ok == NPIC_SUCCESS)
                    NpicMaskInsert_2d (mh, 
                            gs.x[2], gs.x[1], dmg->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_3L : 
        {
            Npic_mask_3l *dmg = NpicCastMask (mg);

            for (i = 0; i < dmg->nb; i++)
            {
                gs.x[1] = dmg->v[i].x;
                gs.x[2] = dmg->v[i].y;
                gs.x[3] = dmg->v[i].z;
                gs.dim = 3;
                gs.half = half;  /* half or full mask */
                
                NpicGsymInit (&gs);
                while (NpicGsymNext (&gs) && mh->gen.ok == NPIC_SUCCESS)
                    NpicMaskInsert_3l (mh, 
                            gs.x[3], gs.x[2], gs.x[1], dmg->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_3D : 
        {
            Npic_mask_3d *dmg = NpicCastMask (mg);

            for (i = 0; i < dmg->nb; i++)
            {
                gs.x[1] = dmg->v[i].x;
                gs.x[2] = dmg->v[i].y;
                gs.x[3] = dmg->v[i].z;
                gs.dim = 3;
                gs.half = half;  /* half or full mask */
                
                NpicGsymInit (&gs);
                while (NpicGsymNext (&gs) && mh->gen.ok == NPIC_SUCCESS)
                    NpicMaskInsert_3d (mh, 
                            gs.x[3], gs.x[2], gs.x[1], dmg->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_4L : 
        {
            Npic_mask_4l *dmg = NpicCastMask (mg);

            for (i = 0; i < dmg->nb; i++)
            {
                gs.x[1] = dmg->v[i].x;
                gs.x[2] = dmg->v[i].y;
                gs.x[3] = dmg->v[i].z;
                gs.x[4] = dmg->v[i].t;
                gs.dim = 4;
                gs.half = half;  /* half or full mask */
                
                NpicGsymInit (&gs);
                while (NpicGsymNext (&gs) && mh->gen.ok == NPIC_SUCCESS)
                    NpicMaskInsert_4l (mh, 
                            gs.x[4], gs.x[3], gs.x[2], gs.x[1], dmg->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_4D : 
        {
            Npic_mask_4d *dmg = NpicCastMask (mg);

            for (i = 0; i < dmg->nb; i++)
            {
                gs.x[1] = dmg->v[i].x;
                gs.x[2] = dmg->v[i].y;
                gs.x[3] = dmg->v[i].z;
                gs.x[4] = dmg->v[i].t;
                gs.dim = 4;
                gs.half = half;  /* half or full mask */
                
                NpicGsymInit (&gs);
                while (NpicGsymNext (&gs) && mh->gen.ok == NPIC_SUCCESS)
                    NpicMaskInsert_4d (mh, 
                            gs.x[4], gs.x[3], gs.x[2], gs.x[1], dmg->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_5L : 
        {
            Npic_mask_5l *dmg = NpicCastMask (mg);

            for (i = 0; i < dmg->nb; i++)
            {
                gs.x[1] = dmg->v[i].x;
                gs.x[2] = dmg->v[i].y;
                gs.x[3] = dmg->v[i].z;
                gs.x[4] = dmg->v[i].t;
                gs.x[5] = dmg->v[i].s;
                gs.dim = 5;
                gs.half = half;  /* half or full mask */
                
                NpicGsymInit (&gs);
                while (NpicGsymNext (&gs) && mh->gen.ok == NPIC_SUCCESS)
                    NpicMaskInsert_5l (mh, 
                            gs.x[5], gs.x[4], gs.x[3], gs.x[2], gs.x[1], dmg->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_5D : 
        {
            Npic_mask_5d *dmg = NpicCastMask (mg);

            for (i = 0; i < dmg->nb; i++)
            {
                gs.x[1] = dmg->v[i].x;
                gs.x[2] = dmg->v[i].y;
                gs.x[3] = dmg->v[i].z;
                gs.x[4] = dmg->v[i].t;
                gs.x[5] = dmg->v[i].s;
                gs.dim = 5;
                gs.half = half;  /* half or full mask */
                
                NpicGsymInit (&gs);
                while (NpicGsymNext (&gs) && mh->gen.ok == NPIC_SUCCESS)
                    NpicMaskInsert_5d (mh, 
                            gs.x[5], gs.x[4], gs.x[3], gs.x[2], gs.x[1], dmg->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_6L : 
        {
            Npic_mask_6l *dmg = NpicCastMask (mg);

            for (i = 0; i < dmg->nb; i++)
            {
                gs.x[1] = dmg->v[i].x;
                gs.x[2] = dmg->v[i].y;
                gs.x[3] = dmg->v[i].z;
                gs.x[4] = dmg->v[i].t;
                gs.x[5] = dmg->v[i].s;
                gs.x[6] = dmg->v[i].r;
                gs.dim = 6;
                gs.half = half;  /* half or full mask */
                
                NpicGsymInit (&gs);
                while (NpicGsymNext (&gs) && mh->gen.ok == NPIC_SUCCESS)
                    NpicMaskInsert_6l (mh, 
                            gs.x[6], gs.x[5], gs.x[4], gs.x[3], gs.x[2], gs.x[1], dmg->v[i].h);
             }
            break;
        }
              
        case NPIC_MASK_6D : 
        {
            Npic_mask_6d *dmg = NpicCastMask (mg);

            for (i = 0; i < dmg->nb; i++)
            {
                gs.x[1] = dmg->v[i].x;
                gs.x[2] = dmg->v[i].y;
                gs.x[3] = dmg->v[i].z;
                gs.x[4] = dmg->v[i].t;
                gs.x[5] = dmg->v[i].s;
                gs.x[6] = dmg->v[i].r;
                gs.dim = 6;
                gs.half = half;  /* half or full mask */
                
                NpicGsymInit (&gs);
                while (NpicGsymNext (&gs) && mh->gen.ok == NPIC_SUCCESS)
                    NpicMaskInsert_6d (mh, 
                            gs.x[6], gs.x[5], gs.x[4], gs.x[3], gs.x[2], gs.x[1], dmg->v[i].h);
             }
            break;
        }
              
        default : {
            NpicError (funcname, NPIC_ERR_UNEX_TYPE, "");
            NpicDestroyMask (mh);
            return NULL;
        }
    }
    
    if (mh->gen.ok != NPIC_SUCCESS) { NpicDestroyMask (mh); mh = NULL; }
    return mh;
}


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