common/clitkImageToImageGenericFilter.cxx

   1 #include "clitkImageToImageGenericFilter.h"
   2 #include "clitkImageCommon.h"
   3
   4 //--------------------------------------------------------------------
   5 clitk::ImageToImageGenericFilterBase::ImageToImageGenericFilterBase(std::string n)
   6   :mIOVerbose(false) {
   7   mFilterName = n;
   8   mListOfAllowedDimensions.clear();
   9   mListOfAllowedPixelTypes.clear();
  10   mFailOnImageTypeError = true;
  11 }
  12 //--------------------------------------------------------------------
  13
  14
  15 //--------------------------------------------------------------------
  16 void clitk::ImageToImageGenericFilterBase::AddImageType(unsigned int d, std::string p) {
  17
  18     mListOfAllowedDimensions.insert(d);
  19     mListOfAllowedPixelTypes.insert(p);
  20 }
  21 //--------------------------------------------------------------------
  22
  23
  24 //--------------------------------------------------------------------
  25 void clitk::ImageToImageGenericFilterBase::SetInputFilenames(const std::vector<std::string> & filenames) {
  26     mInputFilenames=filenames;
  27 }
  28 //--------------------------------------------------------------------
  29
  30
  31 //--------------------------------------------------------------------
  32 void clitk::ImageToImageGenericFilterBase::SetInputFilename(const std::string & filename) {
  33   std::vector<std::string> f;
  34   f.push_back(filename);
  35   SetInputFilenames(f);
  36 }
  37 //--------------------------------------------------------------------
  38
  39
  40 //--------------------------------------------------------------------
  41 void clitk::ImageToImageGenericFilterBase::AddInputFilename(const std::string & filename) {
  42   mInputFilenames.push_back(filename);
  43 }
  44 //--------------------------------------------------------------------
  45
  46
  47 //--------------------------------------------------------------------
  48 void clitk::ImageToImageGenericFilterBase::SetOutputFilename(const std::string & filename) {
  49   mOutputFilenames.clear();
  50   mOutputFilenames.push_back(filename);
  51 }
  52 //--------------------------------------------------------------------
  53
  54
  55 //--------------------------------------------------------------------
  56 void clitk::ImageToImageGenericFilterBase::AddOutputFilename(const std::string & filename)
  57 {
  58   mOutputFilenames.push_back(filename);
  59 }
  60 //--------------------------------------------------------------------
  61
  62
  63 //--------------------------------------------------------------------
  64 void clitk::ImageToImageGenericFilterBase::SetOutputFilenames(const std::vector<std::string> & filenames)
  65 {
  66     mOutputFilenames.clear();
  67     std::copy(filenames.begin(),filenames.end(),mOutputFilenames.begin());
  68 }
  69 //--------------------------------------------------------------------
  70
  71
  72 //--------------------------------------------------------------------
  73 std::string clitk::ImageToImageGenericFilterBase::GetOutputFilename()
  74 {
  75     assert(mOutputFilenames.size() == 1);
  76     return mOutputFilenames.front();
  77 }
  78 //--------------------------------------------------------------------
  79
  80
  81 //--------------------------------------------------------------------
  82 void clitk::ImageToImageGenericFilterBase::GetInputImageDimensionAndPixelType(unsigned int& dim, \
  83         std::string& pixeltype,unsigned int& components)
  84 {
  85   if (mInputFilenames.size())
  86     {
  87       int comp_temp,dim_temp; //clitkCommonImage takes ints
  88       ReadImageDimensionAndPixelType(mInputFilenames[0], dim_temp, pixeltype,comp_temp);
  89       components=comp_temp; dim=dim_temp;
  90     }
  91   else if (mInputVVImages.size())
  92     {
  93       pixeltype=mInputVVImages[0]->GetScalarTypeAsString();
  94       dim=mInputVVImages[0]->GetNumberOfDimensions();
  95       components=mInputVVImages[0]->GetNumberOfScalarComponents();
  96     }
  97   else
  98     assert(false); //No input image, shouldn't happen
  99
 100   if (mIOVerbose) {
 101     std::cout << "Input is " << mDim << "D " << mPixelTypeName << "." << std::endl;
 102   }
 103 }
 104 //--------------------------------------------------------------------
 105
 106
 107 //--------------------------------------------------------------------
 108 vvImage::Pointer clitk::ImageToImageGenericFilterBase::GetOutputVVImage ()
 109 {
 110     assert(mOutputVVImages.size());
 111     return mOutputVVImages[0];
 112 }
 113 //--------------------------------------------------------------------
 114
 115
 116 //--------------------------------------------------------------------
 117 std::vector<vvImage::Pointer> clitk::ImageToImageGenericFilterBase::GetOutputVVImages()
 118 {
 119     return mOutputVVImages;
 120 }
 121 //--------------------------------------------------------------------
 122
 123
 124 //--------------------------------------------------------------------
 125 void clitk::ImageToImageGenericFilterBase::SetInputVVImage (vvImage::Pointer input)
 126 {
 127     mInputVVImages.clear();
 128     mInputVVImages.push_back(input);
 129 }
 130 //--------------------------------------------------------------------
 131
 132
 133 //--------------------------------------------------------------------
 134 void clitk::ImageToImageGenericFilterBase::AddInputVVImage (vvImage::Pointer input)
 135 {
 136     mInputVVImages.push_back(input);
 137 }
 138 //--------------------------------------------------------------------
 139
 140
 141 //--------------------------------------------------------------------
 142 void clitk::ImageToImageGenericFilterBase::SetInputVVImages (std::vector<vvImage::Pointer> input)
 143 {
 144     mInputVVImages=input;
 145 }
 146 //--------------------------------------------------------------------
 147
 148
 149
 150 //--------------------------------------------------------------------
 151 bool clitk::ImageToImageGenericFilterBase::CheckImageType() {
 152   return (CheckDimension() && CheckPixelType());
 153 }
 154 //--------------------------------------------------------------------
 155
 156
 157 //--------------------------------------------------------------------
 158 bool clitk::ImageToImageGenericFilterBase::CheckDimension(unsigned int d) {
 159     return (mListOfAllowedDimensions.find(d) != mListOfAllowedDimensions.end());
 160 }
 161 //--------------------------------------------------------------------
 162
 163
 164 //--------------------------------------------------------------------
 165 bool clitk::ImageToImageGenericFilterBase::CheckPixelType(std::string pt) {
 166     return (mListOfAllowedPixelTypes.find(pt) != mListOfAllowedPixelTypes.end());
 167 }
 168 //--------------------------------------------------------------------
 169
 170
 171 //--------------------------------------------------------------------
 172 bool clitk::ImageToImageGenericFilterBase::CheckDimension() {
 173   return CheckDimension(mDim);
 174 }
 175 //--------------------------------------------------------------------
 176
 177
 178 //--------------------------------------------------------------------
 179 bool clitk::ImageToImageGenericFilterBase::CheckPixelType() {
 180   return CheckPixelType(mPixelTypeName);
 181 }
 182 //--------------------------------------------------------------------
 183
 184
 185 //--------------------------------------------------------------------
 186 void clitk::ImageToImageGenericFilterBase::PrintAvailableImageTypes() {
 187   std::cout << GetAvailableImageTypes();
 188 }
 189 //--------------------------------------------------------------------
 190
 191
 192 //--------------------------------------------------------------------
 193 std::string clitk::ImageToImageGenericFilterBase::GetAvailableImageTypes() {
 194   std::ostringstream oss;
 195   oss << "The filter <" << mFilterName << "> manages ";
 196   for(std::set<unsigned int>::const_iterator i=mListOfAllowedDimensions.begin();
 197           i!=mListOfAllowedDimensions.end(); i++) {
 198     oss << *i << "D ";
 199   }
 200   oss << "images, with pixel types: ";
 201   for(std::set<std::string>::const_iterator i=mListOfAllowedPixelTypes.begin();
 202           i!=mListOfAllowedPixelTypes.end(); i++) {
 203     oss << *i << " ";
 204   }
 205   oss << std::endl;
 206   return oss.str();
 207 }
 208 //--------------------------------------------------------------------
 209
 210
 211
 212 //--------------------------------------------------------------------
 213 void clitk::ImageToImageGenericFilterBase::ImageTypeError() {
 214   std::cerr << "**Error** The filter <" << mFilterName << "> is not available for "
 215             << mDim << "D images with pixel="
 216             << mPixelTypeName << "." << std::endl;
 217   std::cerr << "**Error** Allowed image dim: \t";
 218   for(std::set<unsigned int>::const_iterator i=mListOfAllowedDimensions.begin();
 219           i!=mListOfAllowedDimensions.end(); i++) {
 220       std::cerr << *i << "D ";
 221   }
 222   std::cerr << std::endl << "**Error** Allowed pixel types: \t";
 223   for(std::set<std::string>::const_iterator i=mListOfAllowedPixelTypes.begin();
 224           i!=mListOfAllowedPixelTypes.end(); i++) {
 225       std::cerr << *i << " ";
 226   }
 227   std::cerr << std::endl;
 228   exit(0);
 229 }
 230 //--------------------------------------------------------------------
 231
 232
 233 //--------------------------------------------------------------------
 234 void clitk::ImageToImageGenericFilterBase::SetImageTypeError() {
 235   std::cerr << "TODO ! " << std::endl;
 236   exit(0);
 237 }
 238 //--------------------------------------------------------------------