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