Gdata.h

Go to the documentation of this file.

#ifndef  __JBXL_CPP_GRAPHIC_DATA_H_
#define  __JBXL_CPP_GRAPHIC_DATA_H_
 
#include "ClassBox.h"
#include "gheader.h"
 
#include "Vector.h"
 
 
//
namespace jbxl {
 
 
extern int  ZeroBase;
extern int  TempBase;
 
 
//
//
void    free_CmnHead(CmnHead* hd);      //< 共通ヘッダのメモリ領域を開放する
void    init_CmnHead(CmnHead* hd);
 
#define freeCmnHead  free_CmnHead
#define initCmnHead  init_CmnHead
 
CmnHead getinfo_CmnHead(CmnHead hd);    
 
inline  uByte& CmnHeadBytePoint(CmnHead hd, int i=0, int j=0, int k=0) 
{
    return hd.grptr[(int)i + (int)j*hd.xsize + (int)k*hd.xsize*hd.ysize]; 
}
 
//template <typename T>  MSGraph<T>  copyCmnHead2MSGraph(CmnHead hd,     unsigned int mode=CH2MG_NORMAL);
//template <typename T>  CmnHead     copyMSGraph2CmnHead(MSGraph<T> mgr, unsigned int mode=MG2CH_NORMAL);
//template <typename T>  MSGraph<T>  scalingMSGraph2D(MSGraph<T> vp, double scale)
 
 
 
template <typename T> class MSGraph;
template <typename T> class ExMSGraph;
 
 
template <typename T=sWord> class MSGraph
{
public:
    int xs;                 
    int ys;                 
    int zs;                 
    T*  gp;                 
    T   zero;               
    T   base;               
 
// 以下は必要に応じて設定．
public:
    T   max;                
    T   min;                
    int color;              
    int state;              
    RBound<int>  rbound;    
    double  RZxy;           
    double  norm;           
 
public:
    double  wRateX;         
    double  wRateY;         
    double  wRateZ;         
    double  wZeroX;         
    double  wZeroY;         
    double  wZeroZ;         
    double  wNowX;          
    double  wNowY;          
    double  wNowZ;          
 
//
public:
    MSGraph(int x, int y=1, int z=1, T v=(T)0, T b=(T)0, double rz=1.0) { set(x, y, z, v, b, rz);}
    MSGraph(RBound<int> rb, T v=(T)0, T b=(T)0, double rz=1.0) { set(rb, v, b, rz);}
    MSGraph(void) { init();}
 
    virtual ~MSGraph(void) {}
 
    T&     point(int x, int y=0, int z=0) { return gp[x+xs*y+xs*ys*z];} 
    T      get_vPoint(double x, double y=0., double z=0., int mode=OFF);
    void   set_vPoint(double x, double y=0., double z=0., T cc=(T)0, int mode=OFF);
    void   put_vPoint(double x, double y=0., double z=0., T cc=(T)0, int mode=OFF);
 
    void   set(RBound<int> rb, T v=(T)0, T b=(T)0, double rz=1.0);
    void   set(int x, int y=1, int z=1, T v=(T)0, T b=(T)0, double rz=1.0);
 
    void   init(void);                                      
    bool   isNull(void);                                    
    void   fill(T v=(T)0);                                  
    void   clear(T v);                                      
    void   clear(void);                                     
    void   getm(int x, int y, int z=1, T v=(T)0);           
    void   getm(T v=(T)0);                                  
    void   free(void);                                      
    void   get_minmax(void);                                
    void   set_array(T* ary, int sz=0);                     
    void   contrast(T low, T high);                         
 
    template <typename R> void  mimicry(MSGraph<R> s) {
        set(s.xs, s.ys, s.zs, (T)s.zero, (T)s.base, s.RZxy); 
        rbound = s.rbound;
        color  = s.color;
        state  = s.state;
        max    = s.zero;
        min    = s.zero;
        norm   = s.norm;
    };
 
    template <typename R> void dup(MSGraph<R> s) {
        *this = s;
        getm();
        memcpy(gp, s.gp, xs*ys*zs*sizeof(T));
    };
 
    // for viewport
    void   setWindow(double x1, double y1, double x2, double y2);
    void   setWindow3D(double x1, double y1, double z1, double x2, double y2, double z2);
    
    void   wMove(double x, double y, double z=0.0) {wNowX=x; wNowY=y; wNowZ=z;}
    void   wMove_rel(double x, double y, double z=0.0) {wNowX+=x; wNowY+=y; wNowZ+=z;}
 
 
    MSGraph<T> operator= (ExMSGraph<T>& s);
};
 
 
template <typename T>  void  MSGraph<T>::init(void) 
{
    xs = ys = zs = 0; 
    gp    = NULL; 
    RZxy  = 1.0;
    zero  = (T)0;
    base  = (T)0;
    min   = (T)0;
    max   = (T)0;
    norm  = 1.0;
    color = GRAPH_COLOR_UNKNOWN;
    state = STATE_GRAPH_NOERR;
    rbound.init();
 
    wRateX = wRateY = 1.0;
    wZeroX = wZeroY = 1.0;
    wNowX  = wNowY  = 0.0;
 
    return;
}
 
 
template <typename T>  bool  MSGraph<T>::isNull() 
{
    if (gp==NULL) return true; 
 
#ifdef WIN32
    if (gp==(T*)WIN_DD_NULL) return true; 
#endif
 
    return false;
}
 
 
//
template <typename T>  void  MSGraph<T>::set(RBound<int> rb, T v, T b, double rz) 
{
    set(rb.xmax-rb.xmin+1, rb.ymax-rb.ymin+1, rb.zmax-rb.zmin+1, v, b, rz);
    rbound = rb;
    return;
}
 
 
//
template <typename T>  void  MSGraph<T>::set(int x, int y, int z, T v, T b, double rz) 
{
    if (z<=0) z = 1;
 
    getm(x, y, z, v); 
    if (gp==NULL) return;
 
    base = b;
    if (rz<=0.0) RZxy = 1.0;
    else         RZxy = rz;
    rbound.set(0, x-1, 0, y-1, 0, z-1);
    //
    color = GRAPH_COLOR_UNKNOWN;
    if (z==1) color = GRAPH_COLOR_MONO;
 
    norm  = 1.0;
    state = STATE_GRAPH_NOERR;
    return;
}
 
 
template <typename T> void  MSGraph<T>::getm(int x, int y, int z, T v)
{
    xs = x;
    ys = y;
    zs = z;
    gp = NULL;
    zero = max = min = v;
 
    if (xs>0 && ys>0 && zs>0) {
        gp = (T*)malloc(xs*ys*zs*sizeof(T));
        if (gp==NULL) {
            init();
            state = JBXL_GRAPH_MEMORY_ERROR;
            return;
        }
        for (int i=0; i<xs*ys*zs; i++) gp[i] = (T)v;
    }
}
 
 
template <typename T> void  MSGraph<T>::getm(T v)
{
    gp = NULL;
    zero = max = min = v;
 
    if (xs>0 && ys>0 && zs>0) {
        gp = (T*)malloc(xs*ys*zs*sizeof(T));
        if (gp==NULL) {
            init();
            state = JBXL_GRAPH_MEMORY_ERROR;
            return;
        }
        for (int i=0; i<xs*ys*zs; i++) gp[i] = (T)v;
    }
}
 
 
template <typename T> void  MSGraph<T>::get_minmax(void)
{
    int i;
 
    min = max = gp[0];
 
    for (i=1; i<xs*ys; i++) {
        min = Min(min, gp[i]);
        max = Max(max, gp[i]);
    }
}
 
 
template <typename T> void  MSGraph<T>::set_array(T* ary, int sz)
{
    int size = xs*ys*zs;
 
    if (sz>0) size = Min(size, sz);
    for (int i=0; i<size; i++) gp[i] = ary[i];
}
 
 
template <typename T> void  MSGraph<T>::contrast(T low, T high)
{
    if (max==min) return;
 
    T dif = (high-low)/(max-min);
 
    for (int i=0; i<xs*ys*zs; i++) {
        gp[i] = (gp[i]-min)*dif + low;
    }
 
    return;
}
 
 
template <typename T>  void  MSGraph<T>::fill(T v) 
{       
    for (int i=0; i<xs*ys*zs; i++) gp[i] = v;
    min = max = v;
    return;
}
 
 
template <typename T>  void  MSGraph<T>::clear(T v) 
{       
    for (int i=0; i<xs*ys*zs; i++) gp[i] = v;
    zero = min = max = v;
    return;
}
 
 
template <typename T>  void  MSGraph<T>::clear(void) 
{       
    for (int i=0; i<xs*ys*zs; i++) gp[i] = zero; 
    min = max = zero;
    return;
}
 
 
template <typename T>  void  MSGraph<T>::free(void) 
{  
    if (gp!=NULL) ::free(gp); 
    init();
    return;
}
 
 
template <typename T> T  MSGraph<T>::get_vPoint(double x, double y, double z, int mode)
{
    int   ix, iy, iz;
    int   xx, yy, zz;
    T     ret;
 
    ret = zero;
 
    z  = z*RZxy;  
    if (mode==OFF) {
        ix = (int)(x+0.5) - rbound.xmin;
        iy = (int)(y+0.5) - rbound.ymin;
        iz = (int)(z+0.5) - rbound.zmin;
        if (ix>=0 && ix<xs &&iy>=0 && iy<ys && iz>=0 && iz<zs){
            ret = gp[iz*xs*ys + iy*xs + ix];
        }
    }
    else {
        int n = 0;
        T cc = (T)0;
 
        xx = (int)x - rbound.xmin;
        yy = (int)y - rbound.ymin;
        zz = (int)z - rbound.zmin;
        for (ix=xx; ix<=xx+1; ix++)
        for (iy=yy; iy<=yy+1; iy++)
        for (iz=zz; iz<=zz+1; iz++) {
            if (ix>=0 && ix<xs && iy>=0 && iy<ys && iz>=0 && iz<zs){
                cc = cc + gp[iz*xs*ys + iy*xs + ix];
                n++;
            }
        }
        if (n!=0) ret = cc/n;
    }
 
    return ret;
}
 
 
template <typename T>  void  MSGraph<T>::set_vPoint(double x, double y, double z, T cc, int mode)
{
    int   ix, iy, iz;
    int   xx, yy, zz;
 
    z = z*RZxy;  
    if (mode==OFF) {
        ix = (int)(x+0.5) - rbound.xmin;
        iy = (int)(y+0.5) - rbound.ymin;
        iz = (int)(z+0.5) - rbound.zmin;
        if (ix>=0 && ix<xs && iy>=0 && iy<ys && iz>=0 && iz<zs){
            gp[iz*xs*ys + iy*xs + ix] = cc;
        }
    }
    else {
        xx = (int)x - rbound.xmin;
        yy = (int)y - rbound.ymin;
        zz = (int)z - rbound.zmin;
        for (ix=xx; ix<=xx+1; ix++)
        for (iy=yy; iy<=yy+1; iy++)
        for (iz=zz; iz<=zz+1; iz++) {
            if (ix>=0 && ix<xs && iy>=0 && iy<ys && iz>=0 && iz<zs){
                gp[iz*xs*ys + iy*xs + ix] = cc;
            }
        }
    }
    return;
}
 
 
template <typename T>  void  MSGraph<T>::put_vPoint(double x, double y, double z, T cc, int mode)
{
    int   ix, iy, iz;
    int   xx, yy, zz;
 
    z = z*RZxy;  
    if (mode==OFF) {
        ix = (int)(x+0.5) - rbound.xmin;
        iy = (int)(y+0.5) - rbound.ymin;
        iz = (int)(z+0.5) - rbound.zmin;
        if (ix>=0 && ix<xs && iy>=0 && iy<ys && iz>=0 && iz<zs){
            if (gp[iz*xs*ys + iy*xs + ix]==zero) gp[iz*xs*ys + iy*xs + ix] = cc;
        }
    }
    else {
        xx = (int)x - rbound.xmin;
        yy = (int)y - rbound.ymin;
        zz = (int)z - rbound.zmin;
        for (ix=xx; ix<=xx+1; ix++)
        for (iy=yy; iy<=yy+1; iy++)
        for (iz=zz; iz<=zz+1; iz++) {
            if (ix>=0 && ix<xs && iy>=0 && iy<ys && iz>=0 && iz<zs){
                if (gp[iz*xs*ys + iy*xs + ix]==zero) gp[iz*xs*ys + iy*xs + ix] = cc;
            }
        }
   }
 
    return;
}
 
 
template <typename T> void  MSGraph<T>::setWindow(double x1, double y1, double x2, double y2)
{
    if (x1==x2 || y1==y2) return;
 
    wRateX = (xs-1.0)/Xabs(x2-x1);
    wRateY = (ys-1.0)/Xabs(y2-y1);
    wZeroX = Min(x1, x2);
    wZeroY = Max(y1, y2);
}
 
 
template <typename T> void  MSGraph<T>::setWindow3D(double x1, double y1, double z1, double x2, double y2, double z2)
{
    if (x1==x2 || y1==y2 || z1==z2) return;
 
    wRateX = (xs-1.0)/Xabs(x2-x1);
    wRateY = (ys-1.0)/Xabs(y2-y1);
    wRateZ = (zs-1.0)/Xabs(z2-z1);
    wZeroX = Max(x1, x2);
    wZeroY = Min(y1, y2);
    wZeroZ = Max(z1, z2);
}
 
 
// オペレータ
//
template <typename T>  MSGraph<T> MSGraph<T>::operator= (ExMSGraph<T>& s)
{
    xs     = s.xs;
    ys     = s.ys;
    zs     = s.zs;
    gp     = s.gp;
    zero   = s.zero;
    base   = s.base;
 
    max    = s.max;
    min    = s.min;
    color  = s.color;
    state  = s.state;
    rbound = s.rbound;
    RZxy   = s.RZxy;
    norm   = s.norm;
 
    wRateX = s.wRateX;
    wRateY = s.wRateY;
    wRateZ = s.wRateZ;
    wZeroX = s.wZeroX;
    wZeroY = s.wZeroY;
    wZeroZ = s.wZeroZ;
    wNowX  = s.wNowX;
    wNowY  = s.wNowY;
    wNowZ  = s.wNowZ;
 
    return *this;
}
 
 
 
// 簡易表示インターフェイス
//
template <typename T=uWord> class MSGraphDisp : public CVDisplay
{
public:
 
public:
    MSGraphDisp()  {}
    virtual ~MSGraphDisp() {}
 
    virtual void  displayNew (MSGraph<T> vp) {}
    virtual void  displayNext(MSGraph<T> vp) {}
};
 
 
 
// データ変換
//
 
// ビット和を執れるように設定する．
#define   CH2MG_NORMAL   0   //< ノーマルコピー
#define   CH2MG_NOPARM   1   
 
#define   MG2CH_NORMAL   0   
#define   MG2CH_NOPARM   1   
#define   MG2CH_CONTRAST 2   
#define   MG2CH_OCTET    4   
 
//template <typename T>  MSGraph<T>  copyCmnHead2MSGraph(CmnHead hd,     unsigned int mode=CH2MG_NORMAL);
//template <typename T>  CmnHead     copyMSGraph2CmnHead(MSGraph<T> mgr, unsigned int mode=MG2CH_NORMAL);
 
template <typename T>  MSGraph<T> copyCmnHead2MSGraph(CmnHead hd, unsigned int mode=CH2MG_NORMAL, bool cnt=false)
{
    MSGraph<T> vp;
    int kind = hd.kind & 0x00ff;
 
    vp.init();  // vp.color = GRAPH_COLOR_UNKNOWN;
 
    if (kind==UN_KNOWN_DATA || hd.kind==HEADER_NONE) {
        vp.state = JBXL_GRAPH_HEADER_ERROR;
        return vp;
    }
 
    vp.set(hd.xsize, hd.ysize, hd.zsize);
    if (vp.gp==NULL) { vp.state = JBXL_GRAPH_MEMORY_ERROR; return vp;}
 
    // カラータイプ
    if (kind==JPEG_RGB_DATA || kind==JPEG_MONO_DATA) {
        //if (hd.zsize==3) vp.color = GRAPH_COLOR_PRGB;
        if (hd.zsize==3) vp.color = GRAPH_COLOR_RGB;
    }
    else if (hd.depth==16) {
        vp.color = GRAPH_COLOR_MONO16;
    }
 
    // カウンタ．ここでは，delete禁止
    CVCounter* counter = NULL;
    if (vp.zs>=10 && cnt) {
        counter = GetUsableGlobalCounter();
        if (counter!=NULL) counter->SetMax(vp.zs/10);
    }
 
    int ks, js, ln;
    ln = vp.xs*vp.ys;
 
    if (hd.depth==16){
        sWord* bp = (sWord*)hd.grptr;
        vp.max = vp.min = bp[0];
        for (int k=0; k<vp.zs; k++) {
            ks = k*ln;
            for (int j=0; j<vp.xs*vp.ys; j++) {
                js = j+ ks;
                vp.gp[js] = bp[js];
                vp.max = Max(vp.max, vp.gp[js]);
                vp.min = Min(vp.min, vp.gp[js]);
            }
            
            if (counter!=NULL && k%10==0) {
                counter->StepIt();
                if (counter->isCanceled()) {        //  キャンセル
                    vp.free();
                    vp.state = JBXL_GRAPH_CANCEL;
                    return vp;
                }
            }
 
        }
    }
 
    else if (hd.depth<16){ // ==8
        //int uint = (unsigned char)hd.grptr[0];
        vp.max = vp.min = (T)((unsigned char)hd.grptr[0]);
        for (int k=0; k<vp.zs; k++) {
            ks = k*ln;
            for (int j=0; j<vp.xs*vp.ys; j++) {
                js = j + ks;
                vp.gp[js] = (T)((unsigned char)hd.grptr[js]); 
                vp.max = Max(vp.max, vp.gp[js]);
                vp.min = Min(vp.min, vp.gp[js]);
            }
 
            if (counter!=NULL && k%10==0) {
                counter->StepIt();
                if (counter->isCanceled()) {        //  キャンセル
                    vp.free();
                    vp.state = JBXL_GRAPH_CANCEL;
                    return vp;
                }
            }
        }
    }
 
    else {
        vp.max = vp.min = (T)((uByte)hd.grptr[0]>>(hd.depth-15));
        for (int k=0; k<vp.zs; k++) {
            ks = k*ln;
            for (int j=0; j<vp.xs*vp.ys; j++) {
                js = j + ks;
                vp.gp[js] = (T)((uByte)hd.grptr[js]>>(hd.depth-15));
                vp.max = Max(vp.max, vp.gp[js]);
                vp.min = Min(vp.min, vp.gp[js]);
            }
 
            if (counter!=NULL && k%10==0) {
                counter->StepIt();
                if (counter->isCanceled()) {        //  キャンセル
                    vp.free();
                    vp.state = JBXL_GRAPH_CANCEL;
                    return vp;
                }
            }
        }
    }
 
    // もし存在するなら，ヘッダ部分から Z方向の歪率, rboundを取り出す．
    if (!checkBit(mode, CH2MG_NOPARM)) {
        if (hd.bsize>0 && (kind==CT_DATA || kind==CT_3DM || kind==CT_3D_VOL)) {
            sWord* rz = (sWord*)hd.buf;
            if (rz[9]==RZXY_RATE || checkBit(hd.kind, HAS_RZXY)) {
                double rzm = rz[8]/(double)rz[9];
                if (rzm<5.0 && rzm>0.) vp.RZxy = rzm;
            }
 
            if (rz[10]!=0 && checkBit(hd.kind, HAS_BASE)) {
                vp.base = (T)rz[10];
            }
 
            if (checkBit(hd.kind, HAS_RBOUND)) {
                vp.rbound.xmin = rz[6];
                vp.rbound.xmax = rz[7];
                vp.rbound.ymin = rz[4];
                vp.rbound.ymax = rz[5];
                vp.rbound.zmin = rz[2];
                vp.rbound.zmax = rz[3];
            }
        }
    }
 
    if (counter!=NULL) counter->PutFill();
 
    return  vp;
}
 
 
template <typename T>  CmnHead  copyMSGraph2CmnHead(MSGraph<T>& vp, unsigned int mode=MG2CH_NORMAL, bool cnt=false)
{
    CmnHead  hd;
    CTHead   ct;
 
    memset(&ct, 0, sizeof(CTHead));
    memset(&hd, 0, sizeof(CmnHead));
 
    if (vp.gp==NULL) {
        hd.xsize = JBXL_GRAPH_HEADER_ERROR;
        hd.kind  = HEADER_NONE;
        return hd;
    }
 
    //
    hd.kind  = 0;   // MSGraphからのコピー時には，ヘッダ情報は既に消失している．
    hd.xsize = ct.xsize = ct.cutright= vp.xs;
    hd.ysize = ct.ysize = ct.cutdown = vp.ys;
    hd.zsize = vp.zs;
 
    if (checkBit(mode, MG2CH_OCTET)) hd.depth = 8;
    else                             hd.depth = sizeof(T)*8;
    hd.lsize = hd.xsize*hd.ysize*hd.zsize*(hd.depth/8);
    hd.bsize = sizeof(CTHead);
 
    hd.grptr = (uByte*)malloc(hd.lsize*sizeof(uByte));
    if (hd.grptr==NULL) {
        hd.xsize = JBXL_GRAPH_MEMORY_ERROR;
        hd.kind  = HEADER_NONE;
        return hd;
    }
    memset(hd.grptr, 0, hd.lsize*sizeof(uByte));
 
    hd.buf = (uByte*)malloc(hd.bsize*sizeof(uByte));
    if (hd.buf==NULL) {
        free_CmnHead(&hd);
        hd.xsize = JBXL_GRAPH_MEMORY_ERROR;
        return hd;
    }
    memset(hd.buf, 0, hd.bsize*sizeof(uByte));
 
    // カウンタ．ここでは，delete禁止
    CVCounter* counter = NULL;
 
    if (hd.zsize>=5 && cnt) {
        counter = GetUsableGlobalCounter();
        if (counter!=NULL) counter->SetMax(hd.zsize*2/10);
    }
 
    // 最大値，最小値を求める
    int j, k, ks, js, ln;
    T   max, min;
    max = min = vp.gp[0];
 
    ln = vp.xs*vp.ys;
    for (k=0; k<vp.zs; k++) {
        ks = k*ln;
        for (j=0; j<vp.ys*vp.xs; j++) {
            js = j + ks;
            min = Min(vp.gp[js], min);
            max = Max(vp.gp[js], max);
        }
 
        // カウンタ
        if (counter!=NULL && k%10==0) {
            counter->StepIt();
            if (counter->isCanceled()) {        //  キャンセル
                free_CmnHead(&hd);
                hd.xsize = JBXL_GRAPH_CANCEL;
                return hd;
            }
        }
    }
    vp.max = max;
    vp.min = min;
 
    // ノーマルコピー
    if (mode==MG2CH_NORMAL) {
        memcpy(hd.grptr, vp.gp, hd.lsize);
    }
 
    // 8bitへ変換
    else if (checkBit(mode, MG2CH_OCTET)) {
        // 255以下はコントラスト調整しない
        if (!checkBit(mode, MG2CH_CONTRAST) && vp.max<=255 && vp.min>=0) {
            max = 255;
            min = 0;
        }
 
        for (k=0; k<hd.zsize; k++) {
            ks = k*ln;
            for (j=0; j<hd.xsize*hd.ysize; j++) {
                js = j + ks;
                hd.grptr[js] = (uByte)(((vp.gp[js]-min)/(double)(max-min))*255.);
            }
            
            // カウンタ
            if (counter!=NULL && k%10==0) {
                counter->StepIt();
                if (counter->isCanceled()) {        // キャンセル
                    free_CmnHead(&hd);
                    hd.xsize = JBXL_GRAPH_CANCEL;
                    return hd;
                }
            }
        }
    }
    if (counter!=NULL) counter->PutFill();
 
    memcpy(hd.buf, &ct, hd.bsize);
 
    // Z方向の歪率, rboundの設定．
    if (!checkBit(mode, MG2CH_NOPARM)) {
        sWord* rz  = (sWord*)hd.buf;
        if (vp.RZxy!=1.0) {     
            hd.kind = hd.kind | HAS_RZXY;
            rz[9] = (sWord)RZXY_RATE;
            rz[8] = (sWord)(vp.RZxy*RZXY_RATE);
        }
        if (vp.base!=0) {
            rz[10] = (sWord)vp.base;
            hd.kind |= HAS_BASE;
        }
        rz[2] = (sWord)vp.rbound.zmin;
        rz[3] = (sWord)vp.rbound.zmax;
        rz[4] = (sWord)vp.rbound.ymin;
        rz[5] = (sWord)vp.rbound.ymax;
        rz[6] = (sWord)vp.rbound.xmin;
        rz[7] = (sWord)vp.rbound.xmax;
        hd.kind |= HAS_RBOUND;
    }
 
    return hd;
}
 
 
// 2D画像の拡大・縮小
//
template <typename T>  MSGraph<T>  scalingMSGraph2D(MSGraph<T> vp, double scale)
{
    MSGraph<T> xp;
 
    if (scale==0.0) return xp;
 
    int xs = (int)(vp.xs*scale);
    int ys = (int)(vp.ys*scale);
    int zs = vp.zs;
    int ps = xs*ys;
    if (vp.xs*scale-xs>0.0) xs++;
    if (vp.ys*scale-ys>0.0) ys++;
 
    xp.set(xs, ys, zs);
    xp.getm();
    xp.color = vp.color;
 
    for (int kk=0; kk<zs; kk++) {
        int posk = kk*ps;
        //
        for (int jj=0; jj<ys; jj++) {
            int posj = jj*xs + posk;
            double y = jj/scale;
            int j = (int)y;
            int n = j + 1;
            if (j>vp.ys-1) j = vp.ys-1;
            if (n>vp.ys-1) n = vp.ys-1;
            double bt = y - j;
            //
            for (int ii=0; ii<xs; ii++) {
                double x = ii/scale;
                int i = (int)x;
                int m = i + 1;
                if (j>vp.xs-1) j = vp.xs-1;
                if (n>vp.xs-1) n = vp.xs-1;
                double al = x - i;
                
                T a = vp.point(i, j, kk);
                T b = vp.point(m, j, kk);
                T c = vp.point(i, n, kk);
                T d = vp.point(m, n, kk);
                T p = (T)(a*(1.0-al)*(1.0-bt) + b*al*(1.0-bt) + c*(1.0-al)*bt + d*al*bt);
 
                xp.gp[ii+posj] = p;
            }
        }
    }
        
    return xp;
}
 
 
 
// Tools
//
 
inline  unsigned int  ARGB2Int(unsigned int a, unsigned int r, unsigned int g, unsigned int b)
{
    if (isBigEndian) {      // A-R-G-B
        a = (unsigned int)((a&0x000000ff)<<24);
        r = (unsigned int)((r&0x000000ff)<<16);
        g = (unsigned int)((g&0x000000ff)<<8);
        b = (unsigned int) (b&0x000000ff);
    }
    else {                  // B-G-R-A
        b = (unsigned int)((b&0x000000ff)<<24);
        g = (unsigned int)((g&0x000000ff)<<16);
        r = (unsigned int)((r&0x000000ff)<<8);
        a = (unsigned int) (a&0x000000ff);
    }
 
    unsigned int c = (unsigned int)(a + r + g + b);
    return  c;
}
 
 
#define  RGBA2Int(r, g, b, a)  ARGB2Int((r), (g), (b), (a))
#define  ABGR2Int(a, b, g, r)  ARGB2Int((a), (b), (g), (r))
#define  BGRA2Int(b, g, r, a)  ARGB2Int((b), (g), (r), (a))
 
 
inline  uWord  ARGB2Word(uWord a, uWord r, uWord g, uWord b)
{
    if (isBigEndian) {  // A-R-G-B
        a = (int)(((a&0x00ff)>>4)<<12);
        r = (int)(((r&0x00ff)>>4)<<8);
        g = (int)(((g&0x00ff)>>4)<<4);
        b = (int) ((b&0x00ff)>>4);
    }
    else {              // G-B A-R
        g = (int)(((g&0x00ff)>>4)<<12);
        b = (int)(((b&0x00ff)>>4)<<8);
        a = (int)(((a&0x00ff)>>4)<<4);
        r = (int) ((r&0x00ff)>>4);
    }
 
    uWord c = (uWord)(a + r + g + b);
    return  c;
}
 
 
#define  RGBA2Word(r, g, b, a)  ARGB2Word((r), (g), (b), (a))
#define  ABGR2Word(a, b, g, r)  ARGB2Word((a), (b), (g), (r))
#define  BGRA2Word(b, g, r, a)  ARGB2Word((b), (g), (r), (a))
 
 
inline  uWord  RGB2Word(uWord r, uWord g, uWord b)
{
    r = (int)(((r&0x00ff)>>3)<<11);
    g = (int)(((g&0x00ff)>>2)<<5);
    b = (int) ((b&0x00ff)>>3);
    uWord c = (uWord)(r + g + b);
 
    if (isLittleEndian) swap_byte(&c, 2, 2);
    return  c;
}
 
 
}       // namespace
 
 
#endif