Gio.h

Go to the documentation of this file.

#ifndef  __JBXL_CPP_GRAPHIC_IO_H_
#define  __JBXL_CPP_GRAPHIC_IO_H_
 
#ifdef WIN32
#pragma warning(disable:4995)
#endif
 
 
#include "Gdata.h"
 
 
//
namespace jbxl {
 
 
//  for Simple
//
//template <typename T>  int  writeRasFile(const char *fname, MSGraph<T> vp);
//template <typename T>  MSGraph<T>  readRasFile(const char *fname);
 
 
//  for SUN Raster & User Define
CmnHead readUserSetData(FILE* fp, CmnHead* ch, bool cnt=false); 
CmnHead readRasData(FILE* fp);                                  
int     writeRasData(FILE* fp, CmnHead* ch, int obit=8);        
 
 
//  for CT画像
CmnHead readMoonFile(const char* fn, bool no_ntoh=false);   
CmnHead readMoonData(FILE* fp, unsigned int fsz=0, bool no_ntoh=false); // MOON_DATA形式のファイルを読み込む．
 
int     dicomHeader(FILE* fp, int fsize, int* dsize, int* xsize, int* ysize, int* depth, double* rzxy);
MSGraph<sWord> readDicomFile(const char* fn);
MSGraph<sWord> readDicomData(FILE* fp, int fsz);
 
 
//  for I/O 統合  多種ファイル対応
//template <typename T> MSGraph<T> readGraphicFile  (const char* fname, CmnHead* chd=NULL, bool cnt=false);
//template <typename T> MSGraph<T> readGraphicSlices(const char* frmt, int fst, int fnd, CmnHead* chd);
//template <typename T> int writeGraphicFile(const char *fname, MSGraph<T> vp, int kd=0, int fn=0, int tn=-1, bool cnt=false);
 
CmnHead readXHead      (const char* fn, CmnHead* ch=NULL);                 
CmnHead readXHeadFile  (const char* fn, CmnHead* ch=NULL, bool cnt=false); 
CmnHead readCmnHeadFile(const char* fn, CmnHead* ch, bool cnt=false);      
 
int     writeCmnHeadFile(const char* fn, CmnHead* hd, bool cnt=false);
int     writeCmnHeadData(FILE* fp, CmnHead* hd, bool cnt=false);
 
 
//  C言語との関数対応
/*
CmnHead    readRasData()            read_ras_data()  for C 
CmnHead    readUserSetData()        read_user_data() for C 
int        writeRasData()           write_ras_data() for C
int        writeRasFile()           write_ras_file() for C
MSGraph<T> readRasFile()            read_ras_file()  for C
int        dicomHeader()            dicom_header()   for C
*/
 
 
// ファイル名によるI/Oサポート
template <typename T>  MSGraph<T> readGraphicFile(const char* fname, CmnHead* chd=NULL, bool cnt=false)
{
    MSGraph<T> vp;
    CmnHead    hd;
    CVCounter* counter = NULL;
 
    counter = GetUsableGlobalCounter();
    if (counter!=NULL) {
        counter->SetMax(100);
        counter->MakeChildCounter(80);
    }
 
    vp.init();
 
    hd = readXHeadFile(fname, chd, cnt);
    if (counter!=NULL) counter->DeleteChildCounter();   
 
    // Error
    if (hd.kind==HEADER_NONE) {
        free_CmnHead(&hd);
        if (hd.xsize<0) vp.state = hd.xsize;
        else            vp.state = JBXL_GRAPH_HEADER_ERROR;
        return vp;
    }
 
    // Unknown Data
    int chk = hd.kind & 0x00ff;
    if (chk==UN_KNOWN_DATA) {
        if (chd!=NULL) *chd = hd;
        else  free_CmnHead(&hd);
        vp.state = JBXL_GRAPH_HEADER_ERROR;
        return vp;
    }
 
    if (counter!=NULL) counter->MakeChildCounter(80);
 
    if (cnt) {
        CVCounter* counter = GetUsableGlobalCounter();
        if (counter!=NULL) counter->SetTitle("画像データへ変換");
    } 
 
    if (chd!=NULL) {
        *chd = hd;
        chd->grptr = chd->buf = NULL;
    }
 
    vp = copyCmnHead2MSGraph<T>(hd, CH2MG_NORMAL, cnt);
    free_CmnHead(&hd);
    if (vp.gp==NULL) return vp;
 
    if (ZeroBase!=0) {
        vp.base += ZeroBase;
        for (int i=0; i<vp.xs*vp.ys*vp.zs; i++) vp.gp[i] += (T)ZeroBase;
    }
 
    if (counter!=NULL){
        counter->DeleteChildCounter();
        counter->PutFill();
    }
 
    return  vp;
}
 
 
template <typename T>  MSGraph<T>  readGraphicSlices(const char* fmt, int fst, int fnd, CmnHead* chd=NULL, bool cnt=false)
{
    int   i, k, l, m, chk, kind;
    int   xsize, ysize, zsize, nsize, psize;    // zsize: 1枚の画像のZサイズ．
                                                // nsize: 出来上がりの 3D画像のZサイズ
    char* fr_name;                      
    CmnHead    dhd, hd;
    MSGraph<T> vp, gd;
 
    if (chd!=NULL) {
        DEBUG_MESG("readGraphicSlices: Called with kind = 0x%04x\n", chd->kind);
    }
    else {
        DEBUG_MESG("readGraphicSlices: Called with NULL Header\n");
    }
 
    gd.init();
    vp.init();
 
    // 1枚目（ヘッダ情報）の読み出し
    fr_name = numbering_name(fmt, fst);
    dhd = readXHead(fr_name, chd);
    freeNull(fr_name);
 
    chk = dhd.kind & 0x00ff;
    if (dhd.kind==HEADER_NONE || chk==UN_KNOWN_DATA) {
        DEBUG_MODE PRINT_MESG("readGraphicSlices: ヘッダ読み込みエラー： kind = %d\n", dhd.kind);
        free_CmnHead(&dhd);
        vp.state = JBXL_GRAPH_HEADER_ERROR;
        vp.zs = fst;
        return vp;
    }
    kind  = dhd.kind;
    xsize = dhd.xsize;
    ysize = dhd.ysize;
    zsize = Max(dhd.zsize, 1);
    nsize = zsize*(Xabs(fnd - fst) + 1);
    psize = xsize*ysize*zsize;
    if (dhd.depth==16) gd.color = GRAPH_COLOR_MONO16;
    else               gd.color = GRAPH_COLOR_MONO;
 
    // カウンタ
    CVCounter* counter = NULL;
    if (nsize>=10 && cnt) {
        counter = GetUsableGlobalCounter();
        if (counter!=NULL) {
            //counter->SetTitle("マルチファイル読み込み中");
            counter->SetMax(nsize/10);
            counter->SetPos(1);
        }
    }
 
    // Z軸の歪, ベース，rbound の設定
    if (dhd.buf!=NULL && (chk==CT_DATA || chk==CT_3DM || chk==DICOM_DATA)) {
        sWord* rz  = (sWord*)dhd.buf;
        if (rz[9]==RZXY_RATE || checkBit(dhd.kind, HAS_RZXY)) {
            double rzm = rz[8]/(double)rz[9];
            if (rzm<5.0 && rzm>0.) gd.RZxy = rzm;
        }
 
        if (rz[10]!=0 && checkBit(dhd.kind, HAS_BASE)) {
            gd.base = (T)rz[10];
        }
 
        if (checkBit(dhd.kind, HAS_RBOUND)) {
            gd.rbound.xmin = rz[6];
            gd.rbound.xmax = rz[7];
            gd.rbound.ymin = rz[4];
            gd.rbound.ymax = rz[5];
            gd.rbound.zmin = rz[2];
            gd.rbound.zmax = rz[3];
        }
    }
    free_CmnHead(&dhd);
 
    dhd.kind = kind;
    if (chd!=NULL) dhd.kind |= chd->kind & 0xff00;      // オプション
    *chd = getinfo_CmnHead(dhd);
 
    // データ読み込み（Z軸方向） 1枚目から
    gd.getm(xsize, ysize, nsize);
    if (gd.isNull()) return gd;
 
    l = 0;
    k = fst;
    m = Sign(fnd - fst);
    while(k != fnd+m){
        fr_name = numbering_name(fmt, k);
        hd = readCmnHeadFile(fr_name, &dhd, false); // カウンタ無効
        free(fr_name);
 
        chk = hd.kind & 0x00ff;
        if (hd.kind==HEADER_NONE || chk==UN_KNOWN_DATA) {
            DEBUG_MESG("readGraphicSlices: データ読み込みエラー： n = %d, kind = %d\n", k, hd.kind);
            free_CmnHead(&hd);
            if (l==0) {     // 1枚目でエラー
                gd.free();
                vp.state = JBXL_GRAPH_HEADER_ERROR;
                vp.zs = k;
                return vp;
            }
            else {          // 途中までは読み込み完了
                gd.state = l;
                gd.zs = l*zsize;
                break;
            }
        }
 
        vp = copyCmnHead2MSGraph<T>(hd, CH2MG_NOPARM, false);   // カウンタ無効
        if (vp.isNull()) {
            free_CmnHead(&hd);
            gd.free();
            vp.free();
            vp.state = JBXL_GRAPH_MEMORY_ERROR;
            vp.zs = k;
            return vp;
        }
 
        // gd へコピー
        for (i=0; i<psize; i++) gd.gp[i + psize*l] = vp.gp[i] + ZeroBase;
        if (l==0) {
            gd.min = vp.min;
            gd.max = vp.max;
        }
        else {
            gd.min = Min(gd.min, vp.min);
            gd.max = Max(gd.max, vp.max);
        }
 
        // 後始末
        free_CmnHead(&hd);
        vp.free();
        k += m;
        l++;
 
        // カウンタ
        if (counter!=NULL && l%10==0) {
            counter->StepIt();
            if (counter->isCanceled()) {    // キャンセル
                gd.free();
                vp.state = JBXL_GRAPH_CANCEL;
                vp.zs = k;
                return vp;
            }
        }
    }
    gd.state = l;
    gd.base += ZeroBase;
 
    if (!checkBit(kind, HAS_RBOUND)) gd.rbound.set(0, gd.xs-1, 0, gd.ys-1, 0, gd.zs-1);
    if (chd!=NULL) {
        if ((chd->kind&0x00ff)==USERSET_DATA) {
            CVCounter* counter = GetUsableGlobalCounter();
            if (counter!=NULL) counter->SetTitle("Converting Data");
            *chd = copyMSGraph2CmnHead(gd);
        }
    }
    if (counter!=NULL) {
        counter->PutFill();
        //counter->Stop();
    }
   
    return gd;
}
 
 
template <typename T>  int  writeGraphicFile(const char *fname, MSGraph<T> vp, int kind=0, int mlt=FALSE, int fnum=0, int tnum=0, bool cnt=false)
{
    int     ret;
    CmnHead hd;
    CTHead* chd;
 
    if (fnum<0)            fnum = 0;
    else if (fnum>vp.zs-1) fnum = vp.zs - 1;
    if (tnum<fnum)         tnum = fnum;
    else if (tnum>vp.zs-1) tnum = vp.zs - 1;
 
    // for JPEG
    if ((kind&0x00ff)==JPEG_RGB_DATA) {
        if      (vp.color==GRAPH_COLOR_ARGB)   kind = (kind&0xff00) + JPEG_ARGB_DATA;
        else if (vp.color==GRAPH_COLOR_RGBA)   kind = (kind&0xff00) + JPEG_RGBA_DATA;
 
        if      (vp.color==GRAPH_COLOR_RGB16)  kind = (kind&0xff00) + JPEG16_RGB_DATA;
        else if (vp.color==GRAPH_COLOR_ARGB16) kind = (kind&0xff00) + JPEG16_ARGB_DATA;
        else if (vp.color==GRAPH_COLOR_RGBA16) kind = (kind&0xff00) + JPEG16_RGBA_DATA;
    }
 
    //
    hd.xsize = vp.xs;
    hd.ysize = vp.ys;
    hd.zsize = tnum - fnum + 1; //vp.zs;
    hd.depth = sizeof(T)*8;
    hd.grptr = (uByte*)(vp.gp + vp.xs*vp.ys*fnum);
    if (kind==0) {
        hd.kind  = CT_3DM;
        if (hd.zsize==1) hd.kind = CT_DATA;
    }
    else hd.kind = kind;
 
    hd.lsize = hd.zsize*hd.ysize*hd.zsize*2;
    hd.bsize = sizeof(CTHead);
    hd.buf   = (uByte*)malloc(hd.bsize);
    if (hd.buf==NULL) return JBXL_GRAPH_OPFILE_ERROR;
    memset(hd.buf, 0, hd.bsize);
 
    chd           = (CTHead*)hd.buf;
    chd->xsize    = (sWord)vp.xs;
    chd->ysize    = (sWord)vp.ys;
    chd->ctmin    = (sWord)vp.rbound.zmin;
    chd->ctmax    = (sWord)vp.rbound.zmax;
    chd->cutup    = (sWord)vp.rbound.ymin;
    chd->cutdown  = (sWord)vp.rbound.ymax;
    chd->cutleft  = (sWord)vp.rbound.xmin;
    chd->cutright = (sWord)vp.rbound.xmax;
    hd.kind      |= HAS_RBOUND;
 
    if (vp.RZxy!=1.0) {
        chd->anydata[0] = (sWord)(vp.RZxy*RZXY_RATE);
        chd->anydata[1] = (sWord)RZXY_RATE;
        hd.kind        |= HAS_RZXY;
    }
 
    if (vp.base!=0) {
        chd->anydata[2] = (sWord)vp.base + TempBase;
        hd.kind        |= HAS_BASE;
    }
 
    // 通常の保存
    if (!mlt) {
        ret = writeCmnHeadFile(fname, &hd, cnt);
    }
 
    // マルチスライス
    else {
        // カウンタ
        CVCounter* counter = NULL;
        if (hd.zsize>=10 && cnt) {
            counter = GetUsableGlobalCounter();
            if (counter!=NULL) {
                counter->SetMax((hd.zsize+1)/10);
                counter->SetPos(1);
            }
        }
 
        char filename[LNAME];
        int num = hd.zsize;
        int cnt = fnum;
        hd.zsize = 1;
 
        for (int i=0; i<num; i++) {
            snprintf(filename, LNAME-2, fname, cnt);
            hd.grptr = (uByte*)(vp.gp + vp.xs*vp.ys*cnt);
            ret = writeCmnHeadFile(filename, &hd, false);
            
            if (counter!=NULL && i%10==0) {
                counter->StepIt();
                if (counter->isCanceled()) {    // キャンセル
                    if (hd.buf!=NULL) free(hd.buf);
                    return JBXL_GRAPH_CANCEL;
                }
            }
            if (ret<0) break;
            cnt++;
        }
        if (counter!=NULL) counter->PutFill();
    }
 
    if (hd.buf!=NULL) free(hd.buf);
    
    return ret;
}
 
 
template <typename T>  int  writeRasFile(const char *fname, MSGraph<T> vp)
{
    if (fname==NULL) return JBXL_GRAPH_IVDARG_ERROR;
 
    FILE* fp = fopen(fname, "wb");
    if (fp==NULL) return JBXL_GRAPH_OPFILE_ERROR;
 
    CmnHead hd = copyMSGraph2CmnHead(vp);
    writeRasData(fp, &hd);
 
    fclose(fp);
    return JBXL_NORMAL;
}
 
 
template <typename T>  MSGraph<T>  readRasFile(const char *fname)
{
    MSGraph<T> vp;
    CmnHead    hd;
    FILE* fp;
 
    vp.init();
    fp = fopen(fname, "rb");
    if (fp==NULL) return vp;
 
    hd = readRasData(fp);
    fclose(fp);
 
    vp = copyCmnHead2MSGraph<T>(hd, CH2MG_NORMAL);
    return vp;
}
 
 
}       // namespace
 
 
#endif