FileConversion.hpp

Go to the documentation of this file.

/* ImLib3D
 * Copyright (c) 2001, ULP-IPB Strasbourg.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#ifndef _FileConversion_hpp
#define _FileConversion_hpp
#include<ImLib3D/ImageProcessor.hpp>
#include<ImLib3D/FFT.hpp>
#include<ImLib3D/ConvenienceProcessors.hpp>

#include<avwio/avwio.h>

namespace FileConversion 
{
    inline string AVWImLib3DImageType(string fname)
    {
        string typeName;
        AVW *avw=AvwOpen( fname.c_str(), "r" ); 
        if(!avw){ThrowError("CReadFromFileAVW:: open failed for \"%s\"",fname);}
        short dataType;
        AvwGetDataType ( avw, &dataType ); 
        if(dataType==DT_UNSIGNED_CHAR ){typeName=TypeName<Mask3D>();}
        if(dataType==DT_SIGNED_SHORT  ){typeName=TypeName<Image3Dlinear<short int> >();}
        if(dataType==DT_SIGNED_INT    ){typeName=TypeName<LabelImage3D>();}
        if(dataType==DT_FLOAT         ){typeName=TypeName<Image3Df>();}
        if(dataType==DT_COMPLEX       ){typeName=TypeName<Image3Dcomplexd>();}
        if(dataType==DT_DOUBLE        ){typeName=TypeName<Image3Dd>();}
        AvwClose ( avw ); 
        return typeName;
    }
    
    template <class TTT> 
               inline short AVWType                   (){return DT_UNKNOWN        ;}
    template<> inline short AVWType<byte             >(){return DT_UNSIGNED_CHAR  ;}
    template<> inline short AVWType<short            >(){return DT_SIGNED_SHORT   ;}
    template<> inline short AVWType<int              >(){return DT_SIGNED_INT     ;}
    template<> inline short AVWType<float            >(){return DT_FLOAT          ;}
    template<> inline short AVWType<complex<double>  >(){return DT_COMPLEX        ;}
    template<> inline short AVWType<double           >(){return DT_DOUBLE         ;}
    template <class TTT> 
                struct IsAVWType                    {typedef __false_type type;};
    template <> struct IsAVWType<byte             > {typedef __true_type type;};
    template <> struct IsAVWType<short            > {typedef __true_type type;};
    template <> struct IsAVWType<int              > {typedef __true_type type;};
    template <> struct IsAVWType<float            > {typedef __true_type type;};
    template <> struct IsAVWType<complex<double>  > {typedef __true_type type;};
    template <> struct IsAVWType<double           > {typedef __true_type type;};
//  short AVWType<DT_BINARY         >(){return DT_BINARY         ;}
//  short AVWType<DT_RGB            >(){return DT_RGB            ;}

};



namespace IP3D
{
    template <class ImageType>
    void ImageFromRawData(const typename ImageType::value_type *data,const Size3D &size,string order,ImageType &res,bool reverseEndian=false)
    {
        typedef typename ImageType::value_type Im3DValue;
        res.Resize(size);
        Vect3Di vorder;
        for(int i=0;i<3;i++)
        {
            vorder(i)=order[i]-'X';
            if(vorder(i)<0 || vorder(i)>2){ThrowError("CImageFromRawData::bad order string");}
        }
        Vect3Di fact;
        Vect3Di vsize=size.GetV();
        fact(vorder(0))=1;
        fact(vorder(1))=vsize(vorder(0));
        fact(vorder(2))=vsize(vorder(0))*vsize(vorder(1));

        for(typename ImageType::iteratorXYZ p=res.begin();p!=res.end();++p)
        {
            const Im3DValue &v=data[p.x*fact.x+p.y*fact.y+p.z*fact.z];
            if(!reverseEndian){*p=v;}
            else{ReverseEndian(v,*p);}          
        }
    }
};
namespace IP3D
{
    template <class ImageType>
    void RawDataFromImage(const ImageType &src,string order,typename ImageType::value_type **pres,bool reverseEndian=false)
    {
        typedef typename ImageType::value_type Im3DValue;
        *pres=new Im3DValue[src.GetNVoxels()];
        Im3DValue *res=*pres;
        Vect3Di vorder;
        for(int i=0;i<3;i++)
        {
            vorder(i)=order[i]-'X';
            if(vorder(i)<0 || vorder(i)>2){ThrowError("CRawDataFromImage::bad order string");}
        }
        Vect3Di fact;
        Vect3Di vsize=src.SizeV();
        fact(vorder(0))=1;
        fact(vorder(1))=vsize(vorder(0));
        fact(vorder(2))=vsize(vorder(0))*vsize(vorder(1));

        for(typename ImageType::const_iteratorXYZ p=src.begin();p!=src.end();++p)
        {
            Im3DValue v;
            if(!reverseEndian){v=*p;}
            else{ReverseEndian(*p,v);}          
            res[p.x*fact.x+p.y*fact.y+p.z*fact.z]=v;
        }
    }
};


namespace IP3D
{
    template <class ImageType >
    void WriteToFileAVW(const ImageType &src,const string &fname)
    {
        using namespace FileConversion;
        if(IsSameType<__false_type,typename IsAVWType<typename ImageType::value_type>::type>())
        {
            ThrowError("IP3D::WriteToFileAVW ImageType:\"%s\" can not be converted to AVW",TypeName<ImageType>());
        }
        AVW *avw=AvwOpen( fname.c_str(), "w" ); 
        if(!avw){ThrowError("CWriteToFileAVW:: open failed for \"%s\"",fname);}
        AvwInitHeader ( avw, FileConversion::AVWType<typename ImageType::value_type>(), 
                        src.Width(), src.Height(), src.Width(), 1, 
                        1,1,1, 0, // dx,dy,dz,dt
                        3, "mm" ); 
        size_t nVolsRes=AvwWriteVolumes (avw, (const void *)src.GetData(), 1 ); 
        printf("CWriteToFileAVW:: wrote %d volumes\n",nVolsRes);
        AvwClose ( avw ); 
    }
};

namespace IP3D
{
    template <class ImageType >
    void ReadFromFileAVW(const string &fname,ImageType &res)
    {
        using namespace FileConversion;
        AVW *avw=AvwOpen( fname.c_str(), "r" ); 
        if(!avw){ThrowError("CReadFromFileAVW:: open failed for \"%s\"",fname);}
        short w,h,d,v;
        short dataType;
        AvwGetDataType ( avw, &dataType ); 
        if(dataType!=FileConversion::AVWType<typename ImageType::value_type>())
        {
                ThrowError("CReadFromFileAVW:: template image data type:%d does not match data type in avw file:%d",
                         FileConversion::AVWType<typename ImageType::value_type>(),dataType);
        }
        AvwGetDim ( avw,&w,&h,&d,&v ); 
        char orientation[1000];
        AvwGetOrientation ( avw, orientation ); 
        printf("CReadFromFileAVW:: image size:%d %d %d nvol:%d  orientation:\"%s\"\n",w,h,d,v,orientation);
        res.Resize(Size3D(w,h,d));
        size_t nVolsRes=AvwReadVolumes (avw, (void *)res.GetData(), 1 ); 
        printf("CReadFromFileAVW:: read %d volumes\n",nVolsRes);
        AvwClose ( avw ); 
    }
};

namespace IP3D
{
        void ReadFromFileBruker(const string &fname,int imageNumber,Image3Dlinear<short int> &res);
};

namespace IP3D
{
    template <class ImageType>
    void ExportImageSlice(const ImageType &src,int direction,int position,const string &fname,float rescale=1)
    {
        bool doRescaling=(rescale!=0);
        bool fullImageRescale=(rescale <0);
        rescale=fabs(rescale);

        int c1=(direction+1)%3;
        int c2=(direction+2)%3;
        int width=src.SizeV()(c1);
        int height=src.SizeV()(c2);
        typedef byte ppmtype;
        ppmtype *res=new ppmtype[width*height];
        uint maxvalue=(1<<(8*sizeof(ppmtype)))-1;

        float minv,maxv;
        if(doRescaling)
        {
            vector<float> values;
            values.reserve(fullImageRescale ? src.GetNVoxels() : width*height);
            for(typename ImageType::const_iteratorXYZ p=src.begin();p!=src.end();++p)
            {
                if(fullImageRescale || p.Pos()(direction)==position){values.push_back((float)(*p));}
            }
            float margin=(1-rescale)/2.0;
            int n1=(int)floor(   margin *(values.size()-1));
            int n2=(int)ceil ((1-margin)*(values.size()-1));
            nth_element(values.begin(),values.begin()+n1,values.end());
            minv=values[n1];
            nth_element(values.begin(),values.begin()+n2,values.end());
            maxv=values[n2];
            printf("minv:%f maxv:%f rescale:%f margin:%f n1:%d n2:%d\n",minv,maxv,rescale,margin,n1,n2);
        }
        for(int x=0;x<width;x++)
        for(int y=0;y<height;y++)
        {
            Vect3Di pos;
            pos(direction)=position;
            pos(c1)=x;
            pos(c2)=y;
            if(doRescaling)
            {               
                res[x+y*width]=(ppmtype)(( (min(maxv,max(minv,(float)src(pos)))-minv)/(maxv-minv))*maxvalue);
            }
            else
            {
                res[x+y*width]=(ppmtype)src(pos);
            }
        }
        FILE *F=fopen(fname.c_str(),"w");
        if(!F){ThrowError("IP3D::ExportImageSlice output file \"%s\" open failed",fname);}
        fprintf(F,"P5\n%d %d\n%d\n",width,height,maxvalue);
        fwrite((void *)res,width*height*sizeof(ppmtype),1,F);
        fclose(F);
        delete [] res;
    }
};

#endif// _FileConversion_hpp

---