src2/creaImageIOImageReader.cpp

   1 #include <creaImageIOImageReader.h>
   2 #include <creaImageIOTreeAttributeDescriptor.h>
   3 #include <creaImageIOSystem.h>
   4
   5 #include <creaImageIOVtkImageReader.h>
   6 #include <creaImageIODicomImageReader.h>
   7
   8 #include <vtkPNGReader.h>
   9 #include <vtkTIFFReader.h>
  10 #include <vtkJPEGReader.h>
  11 #include <vtkBMPReader.h>
  12 #include <vtkSLCReader.h>
  13 #include <vtkMetaImageReader.h>
  14 //#include <vtkGESignalReader.h>
  15
  16
  17
  18 #include "boost/filesystem/path.hpp"
  19
  20 namespace creaImageIO
  21 {
  22
  23
  24
  25   //=====================================================================
  26   /*
  27   void IRFillFields(DicomNode* node,
  28                   GDCM_NAME_SPACE::File* gdcmFile)
  29   {
  30     const DicomNodeTypeDescription::FieldDescriptionMapType& dm
  31       = node->GetTypeDescription().GetFieldDescriptionMap();
  32     DicomNodeTypeDescription::FieldDescriptionMapType::const_iterator i;
  33
  34
  35     DicomNode::FieldValueMapType& vm = node->GetFieldValueMap();
  36     for (i=dm.begin(); i!=dm.end(); ++i)
  37       {
  38         if ( (i->second.flags==0) &&
  39              (i->second.group!=0) &&
  40              (i->second.element!=0) )
  41           {
  42                 uint16_t gr = i->second.group;
  43                 uint16_t el = i->second.element;
  44
  45                 std::string val = gdcmFile->GetEntryString(gr,el);
  46
  47             vm[i->first] = irclean(val);
  48           }
  49         else
  50           {
  51             vm[i->first] = "";
  52           }
  53       }
  54   }
  55   */
  56   //=====================================================================
  57
  58
  59
  60
  61   //=====================================================================
  62   ImageReader::ImageReader()
  63     :
  64     mUnreadableImage(0),
  65     mLastFilename("&&&&&&&&&&&&&&&&&&&&&&&&&&&&&"),
  66     mLastReader(0)
  67
  68   {
  69     //    std::cout << "#### ImageReader::ImageReader()"<<std::endl;
  70     if (mUnreadableImage!=0) return;
  71
  72     Register(new VtkImageReader(vtkPNGReader::New()));
  73     Register(new VtkImageReader(vtkTIFFReader::New()));
  74     Register(new VtkImageReader(vtkJPEGReader::New()));
  75     Register(new VtkImageReader(vtkBMPReader::New()));
  76     Register(new VtkImageReader(vtkSLCReader::New()));
  77     Register(new VtkImageReader(vtkMetaImageReader::New(),"MHD",".mhd"));
  78     //   Register(new VtkImageReader(vtkGESignalReader::New()));
  79     Register(new DicomImageReader);
  80
  81     /*
  82     std::cout << "## Registered file extensions : "<<std::endl;
  83     std::vector<std::string>::const_iterator i;
  84     for (i=GetKnownExtensions().begin();
  85          i!=GetKnownExtensions().end();
  86          i++)
  87       {
  88         std::cout << "'"<<(*i)<<"'"<<std::endl;
  89       }
  90     */
  91     //
  92     mUnreadableImage = vtkImageData::New();
  93     int dim[3];
  94     dim[0] = dim[1] = 128;
  95     dim[2] = 1;
  96     mUnreadableImage->SetDimensions ( dim );
  97     mUnreadableImage->SetScalarTypeToUnsignedChar();
  98     mUnreadableImage->AllocateScalars();
  99     for (int i=0;i<dim[0];i++)
 100       for (int j=0;j<dim[1];j++)
 101         mUnreadableImage->SetScalarComponentFromFloat(i,j,0,0,0);
 102     for (int i=0;i<dim[0];i++)
 103       {
 104         mUnreadableImage->SetScalarComponentFromFloat(i,i,0,0,255);
 105         mUnreadableImage->SetScalarComponentFromFloat(dim[0]-1-i,i,0,0,255);
 106       }
 107
 108
 109
 110   }
 111   //=====================================================================
 112
 113   //=====================================================================
 114   ImageReader::~ImageReader()
 115   {
 116     //    std::cout << "#### ImageReader::~ImageReader()"<<std::endl;
 117     std::vector<SpecificImageReader*>::iterator i;
 118     for (i=mReader.begin(); i!=mReader.end(); i++)
 119       {
 120         //      std::cout << "#### ImageReader::UnRegister("
 121         //                << (*i)->GetName()<<")"<<std::endl;
 122         delete (*i);
 123       }
 124     mReader.clear();
 125     if (mUnreadableImage!=0)
 126       {
 127         mUnreadableImage->Delete();
 128         mUnreadableImage = 0;
 129       }
 130   }
 131   //=====================================================================
 132
 133   //=====================================================================
 134   void ImageReader::Register(SpecificImageReader* r)
 135   {
 136     //    std::cout << "#### ImageReader::Register("<<r->GetName()<<")"<<std::endl;
 137     mReader.push_back(r);
 138     r->PushBackExtensions(mKnownExtensions);
 139   }
 140   //=====================================================================
 141
 142   //=====================================================================
 143   // Returns true iff the file is readable
 144   bool ImageReader::CanRead( const std::string& filename,
 145                              const std::string& exclude )
 146   {
 147     //    std::cout << "## ImageReader::CanRead("<<filename<<")"<<std::endl;
 148     bool ok = false;
 149     std::vector<SpecificImageReader*>::iterator i;
 150     for (i=mReader.begin(); i!=mReader.end(); i++)
 151       {
 152         if ((*i)->GetName()==exclude) continue;
 153         ok = (*i)->CanRead(filename);
 154         if (ok)
 155           {
 156             mLastFilename = filename;
 157             mLastReader = *i;
 158             break;
 159           }
 160       }
 161     return ok;
 162   }
 163   //=====================================================================
 164
 165   //=====================================================================
 166   // Reads the file (CanRead must be called before : no test here)
 167   vtkImageData*  ImageReader::ReadImage( const std::string& filename,
 168                                          const std::string& exclude )
 169   {
 170     //    std::cout << "## ImageReader::Read("<<filename<<")"<<std::endl;
 171     if (mLastFilename!=filename)
 172       {
 173         if (!CanRead(filename,exclude))
 174           {
 175             //      std::cout << "  -- Cannot read image "<<std::endl;
 176             vtkImageData* im = vtkImageData::New();
 177             im->ShallowCopy(mUnreadableImage);
 178             return im;
 179           }
 180       }
 181     vtkImageData* i = mLastReader->ReadImage(mLastFilename);
 182     //    std::cout << "i="<<i<<std::endl;
 183     if (i==0)
 184       {
 185         //      std::cout << "i=UNREAD"<<i<<std::endl;
 186         i = vtkImageData::New();
 187         i->ShallowCopy(mUnreadableImage);
 188       }
 189     //    std::cout << "i="<<i<<std::endl;
 190     return i;
 191   }
 192   //=====================================================================
 193
 194
 195   //=====================================================================
 196    void ImageReader::ReadAttributes(const std::string& filename,
 197                                     std::map<std::string,std::string>& attr)
 198    {
 199      // std::cout << "ImageReader::ReadDicomInfo '"<<filename<<"'"<<std::endl;
 200     //    std::cout << "## ImageReader::Read("<<filename<<")"<<std::endl;
 201     if (mLastFilename!=filename)
 202       {
 203         if (!CanRead(filename))
 204           {
 205             return;
 206           }
 207       }
 208     mLastReader->ReadAttributes(mLastFilename,attr);
 209    }
 210   //=====================================================================
 211
 212
 213
 214 } // namespace creaImageIO