added function semanticseg() for 3d cached examples

semseg/SemSegContextTree.h

@@ -168,6 +168,11 @@ class SemSegContextTree : public SemanticSegmentation
      */
     void semanticseg ( CachedExample *ce,   NICE::ImageT<int> & segresult,  NICE::MultiChannelImageT<double> & probabilities );
 
+    void semanticseg ( CachedExample *ce,
+                       NICE::MultiChannelImageT<int> & segresult,
+                       NICE::MultiChannelImage3DT<double> & probabilities )
+    {}
+
     /**
      * the main training method
      * @param md training data

semseg/SemSegContextTree3D.h

@@ -233,9 +233,14 @@ public:
   void train ( const MultiDataset *md );
 
   // deprecated stuff
-  virtual void semanticseg ( OBJREC::CachedExample *ce,
-                             NICE::ImageT<int> & segresult,
-                             NICE::MultiChannelImageT<double> & probabilities )
+  void semanticseg ( CachedExample *ce,
+                     NICE::ImageT<int> & segresult,
+                     NICE::MultiChannelImageT<double> & probabilities )
+  {}
+
+  void semanticseg ( CachedExample *ce,
+                     NICE::MultiChannelImageT<int> & segresult,
+                     NICE::MultiChannelImage3DT<double> & probabilities )
   {}
 
   bool active3DMode ()

semseg/SemSegCsurka.h

@@ -235,6 +235,11 @@ class SemSegCsurka : public SemanticSegmentation
                        NICE::ImageT<int> & segresult,
                        NICE::MultiChannelImageT<double> & probabilities );
 
+    void semanticseg ( CachedExample *ce,
+                       NICE::MultiChannelImageT<int> & segresult,
+                       NICE::MultiChannelImage3DT<double> & probabilities )
+    {}
+
     /** this procedure is equal semanticseg, if there is no post process
     * @param ce image data
     * @param segresult result of the semantic segmentation with a label for each pixel

semseg/SemSegLocal.h

@@ -40,6 +40,11 @@ class SemSegLocal : public SemanticSegmentation
                        NICE::ImageT<int> & segresult,
                        NICE::MultiChannelImageT<double> & probabilities );
 
+    void semanticseg ( CachedExample *ce,
+                       NICE::MultiChannelImageT<int> & segresult,
+                       NICE::MultiChannelImage3DT<double> & probabilities )
+    {}
+
 };
 
 

semseg/SemSegNovelty.h

@@ -245,6 +245,11 @@ class SemSegNovelty : public SemanticSegmentation
                        NICE::ImageT<int> & segresult,
                        NICE::MultiChannelImageT<double> & probabilities );
 
+    void semanticseg ( CachedExample *ce,
+                       NICE::MultiChannelImageT<int> & segresult,
+                       NICE::MultiChannelImage3DT<double> & probabilities )
+    {}
+
     /**
      * @brief visualize a specific region in the original image
      *

semseg/SemSegNoveltyBinary.h

@@ -197,6 +197,11 @@ class SemSegNoveltyBinary : public SemanticSegmentation
                        NICE::ImageT<int> & segresult,
                        NICE::MultiChannelImageT<double> & probabilities );
     
+    void semanticseg ( CachedExample *ce,
+                       NICE::MultiChannelImageT<int> & segresult,
+                       NICE::MultiChannelImage3DT<double> & probabilities )
+    {}
+
     /**
      * @brief visualize a specific region in the original image
      *

semseg/SemSegObliqueTree.cpp

@@ -215,15 +215,50 @@ void SemSegObliqueTree::semanticseg(
 
     Example pce ( ce, 0, 0 );
     for ( int y = 0 ; y < ysize ; y++ )
-      for ( int x = 0 ; x < xsize ; x++ )
-      {
-        pce.x = x ;
-        pce.y = y;
-        ClassificationResult r = fpcrf->classify ( pce );
-        segresult.setPixel ( x, y, r.classno );
-        for ( int i = 0 ; i < ( int ) probabilities.channels(); i++ )
-          probabilities[i](x,y) = r.scores[i];
-      }
+        for ( int x = 0 ; x < xsize ; x++ )
+        {
+            pce.x = x;
+            pce.y = y;
+            ClassificationResult r = fpcrf->classify ( pce );
+            segresult.setPixel ( x, y, r.classno );
+            for ( int i = 0 ; i < ( int ) probabilities.channels(); i++ )
+                probabilities[i](x,y) = r.scores[i];
+        }
+}
+
+/** classification function 3d */
+void SemSegObliqueTree::semanticseg(
+        OBJREC::CachedExample *ce,
+        NICE::MultiChannelImageT<int> &segresult,
+        NICE::MultiChannelImage3DT<double> &probabilities )
+{
+    // for speed optimization
+    FPCRandomForests *fpcrf = dynamic_cast<FPCRandomForests *> ( fpc );
+
+    int xsize, ysize, zsize;
+    ce->getImageSize3 ( xsize, ysize, zsize );
+    probabilities.reInit ( xsize, ysize, zsize, classNames->getMaxClassno() + 1 );
+    segresult.reInit ( xsize, ysize, (unsigned int)zsize );
+
+    vector<DecisionTree *> forest = fpcrf->getForest ();
+    DecisionNode *root = forest[0]->getRoot ();
+    ConvolutionFeature* cf = dynamic_cast<ConvolutionFeature*> (root->f);
+
+    preprocessChannels( ce, cf->isColorMode() ); //FIXME!!!
+
+    Example pce ( ce, 0, 0, 0 );
+    for ( int z = 0 ; z < zsize; z++ )
+        for ( int y = 0 ; y < ysize ; y++ )
+            for ( int x = 0 ; x < xsize ; x++ )
+            {
+                pce.x = x;
+                pce.y = y;
+                pce.z = z;
+                ClassificationResult r = fpcrf->classify ( pce );
+                segresult.set ( x, y, z, r.classno );
+                for ( int i = 0 ; i < ( int ) probabilities.channels(); i++ )
+                    probabilities[i](x,y,z) = r.scores[i];
+            }
 }
 
 ///////////////////// INTERFACE PERSISTENT /////////////////////

semseg/SemSegObliqueTree.h

@@ -89,6 +89,16 @@ class SemSegObliqueTree : public SemanticSegmentation
                            NICE::ImageT<int> &segresult,
                            NICE::MultiChannelImageT<double> &probabilities );
 
+        /**
+         * Classify each voxel of a 3D image (image stack)
+         * @author Sven Sickert
+         * @param ce 3d image data
+         * @param segresult segmentation results (output)
+         * @param probabilities probabilities for each pixel (output)
+         */
+        void semanticseg ( OBJREC::CachedExample *ce,
+                           NICE::MultiChannelImageT<int> & segresult,
+                           NICE::MultiChannelImage3DT<double> & probabilities );
 
         ///////////////////// INTERFACE PERSISTENT /////////////////////
         // interface specific methods for store and restore

semseg/SemanticSegmentation.cpp

@@ -23,9 +23,9 @@ using namespace NICE;
 SemanticSegmentation::SemanticSegmentation ( )
     : iterationCountSuffix(1)
 {
-  this->imagetype = IMAGETYPE_RGB;
-  
-  this->classNames = new ClassNames();
+    this->imagetype = IMAGETYPE_RGB;
+
+    this->classNames = new ClassNames();
 
 }
 
@@ -33,17 +33,17 @@ SemanticSegmentation::SemanticSegmentation ( const Config *conf,
                                              const ClassNames *classNames )
     : iterationCountSuffix(1)
 {
-  ///////////
-  // same code as in empty constructor - duplication can be avoided with C++11 allowing for constructor delegation
-  /////////// 
-  
-  ///////////
-  // here comes the new code part different from the empty constructor
-  /////////// 
-
-  this->classNames = classNames; 
-  
-  this->initFromConfig( conf ); 
+    ///////////
+    // same code as in empty constructor - duplication can be avoided with C++11 allowing for constructor delegation
+    ///////////
+
+    ///////////
+    // here comes the new code part different from the empty constructor
+    ///////////
+
+    this->classNames = classNames;
+
+    this->initFromConfig( conf );
 }
 
 SemanticSegmentation::~SemanticSegmentation()
@@ -52,60 +52,72 @@ SemanticSegmentation::~SemanticSegmentation()
 
 void SemanticSegmentation::initFromConfig(const Config* conf, const string& s_confSection)
 {
-  std::string imagetype_s = conf->gS ( "main", "imagetype", "rgb" );
-  coarseMode = conf->gB( "main", "coarse_mode", false );
-
-  if ( imagetype_s == "rgb" )
-    imagetype = IMAGETYPE_RGB;
-  else if ( imagetype_s == "gray" )
-    imagetype = IMAGETYPE_GRAY;
-  else {
-    fprintf ( stderr, "SemanticSegmentation:: unknown image type option\n" );
-    exit ( -1 );
-  }
-
-  // dangerous!!!
-  Preprocess::Init ( conf );
+    std::string imagetype_s = conf->gS ( "main", "imagetype", "rgb" );
+    coarseMode = conf->gB( "main", "coarse_mode", false );
+
+    if ( imagetype_s == "rgb" )
+        imagetype = IMAGETYPE_RGB;
+    else if ( imagetype_s == "gray" )
+        imagetype = IMAGETYPE_GRAY;
+    else {
+        fprintf ( stderr, "SemanticSegmentation:: unknown image type option\n" );
+        exit ( -1 );
+    }
+
+    // dangerous!!!
+    Preprocess::Init ( conf );
 }
 
 ///////////////////// ///////////////////// /////////////////////
 //                      SEGMENTATION STUFF
 ///////////////////// ///////////////////// /////////////////////
 
-void SemanticSegmentation::semanticseg ( const std::string & filename,
-    NICE::ImageT<int> & segresult,
-    NICE::MultiChannelImageT<double> & probabilities )
+void SemanticSegmentation::semanticseg (
+        const std::string & filename,
+        NICE::ImageT<int> & segresult,
+        NICE::MultiChannelImageT<double> & probabilities )
 {
-  Globals::setCurrentImgFN ( filename );
-  CachedExample *ce;
-  if ( imagetype == IMAGETYPE_RGB )
-  {
-    NICE::ColorImage img = Preprocess::ReadImgAdvRGB ( filename );
-    ce = new CachedExample ( img );
-  } else {
-
-    NICE::Image img = Preprocess::ReadImgAdv ( filename );
-    ce = new CachedExample ( img );
-  }
-#ifdef DEBUG_PRINTS
-  fprintf ( stderr, "Starting Semantic Segmentation !\n" );
-#endif
-  this->semanticseg ( ce, segresult, probabilities );
-  delete ce;
+    Globals::setCurrentImgFN ( filename );
+    CachedExample *ce;
+    if ( imagetype == IMAGETYPE_RGB )
+    {
+        NICE::ColorImage img = Preprocess::ReadImgAdvRGB ( filename );
+        ce = new CachedExample ( img );
+    } else {
+
+        NICE::Image img = Preprocess::ReadImgAdv ( filename );
+        ce = new CachedExample ( img );
+    }
+
+    this->semanticseg ( ce, segresult, probabilities );
+    delete ce;
+}
+
+void SemanticSegmentation::semanticseg (
+        const std::vector<std::string> & filelist,
+        NICE::MultiChannelImageT<int> & segresult,
+        NICE::MultiChannelImage3DT<double> & probabilities )
+{
+    NICE::MultiChannelImage3DT<int> img;
+    make3DImage( filelist, img );
+    CachedExample *ce = new CachedExample (img);
+
+    this->semanticseg ( ce, segresult, probabilities );
+    delete ce;
 }
 
 void SemanticSegmentation::classify ( const std::vector<std::string> & filelist,
                                       NICE::MultiChannelImageT<int> & segresult,
                                       NICE::MultiChannelImage3DT<double> & probabilities )
 {
-  for ( int it = 0; it < ( int ) filelist.size(); it++ )
-  {
-    NICE::MultiChannelImageT<double> probs;
-    NICE::ImageT<int> res ( segresult.width(), segresult.height() );
-    this->semanticseg( filelist[it], res, probs );
-    probabilities.addChannel( probs );
-    segresult.addChannel( res );
-  }
+    for ( int it = 0; it < ( int ) filelist.size(); it++ )
+    {
+        NICE::MultiChannelImageT<double> probs;
+        NICE::ImageT<int> res ( segresult.width(), segresult.height() );
+        this->semanticseg( filelist[it], res, probs );
+        probabilities.addChannel( probs );
+        segresult.addChannel( res );
+    }
 }
 
 ///////////////////// ///////////////////// /////////////////////
@@ -114,248 +126,172 @@ void SemanticSegmentation::classify ( const std::vector<std::string> & filelist,
 void SemanticSegmentation::convertLSetToSparseExamples ( Examples &examples, LabeledSetVector &lvec )
 {
 #ifdef DEBUG_PRINTS
-  cout << "SemSegRegionBased::convertLSetToExamples starts" << endl;
+    cout << "SemSegRegionBased::convertLSetToExamples starts" << endl;
 #endif
-  for ( map< int, vector<NICE::Vector *> >::iterator iter = lvec.begin(); iter != lvec.end(); ++iter )
-  {
-    for ( int j = 0; j < ( int ) iter->second.size(); j++ )
+    for ( map< int, vector<NICE::Vector *> >::iterator iter = lvec.begin(); iter != lvec.end(); ++iter )
     {
-      Vector &tmp = * ( iter->second[j] );
-      int dim = tmp.size();
-      SparseVector *vec = new SparseVector ( dim );
-      for ( int j = 0; j < dim; j++ )
-      {
-        if ( tmp[j] != 0.0 )
+        for ( int j = 0; j < ( int ) iter->second.size(); j++ )
         {
-          ( *vec ) [j] = tmp[j];
+            Vector &tmp = * ( iter->second[j] );
+            int dim = tmp.size();
+            SparseVector *vec = new SparseVector ( dim );
+            for ( int j = 0; j < dim; j++ )
+            {
+                if ( tmp[j] != 0.0 )
+                {
+                    ( *vec ) [j] = tmp[j];
+                }
+            }
+            Example ex;
+            ex.svec = vec;
+            examples.push_back ( pair<int, Example> ( iter->first, ex ) );
         }
-      }
-      Example ex;
-      ex.svec = vec;
-      examples.push_back ( pair<int, Example> ( iter->first, ex ) );
     }
-  }
-  lvec.clear();
+    lvec.clear();
 #ifdef DEBUG_PRINTS
-  cout << "SemSegRegionBased::convertLSetToExamples finished" << endl;
+    cout << "SemSegRegionBased::convertLSetToExamples finished" << endl;
 #endif
 }
 
 void SemanticSegmentation::convertLSetToExamples ( Examples &examples, LabeledSetVector &lvec, const bool & removeOldDataPointer )
 {
 #ifdef DEBUG_PRINTS
-  cout << "SemSegRegionBased::convertLSetToExamples starts" << endl;
+    cout << "SemSegRegionBased::convertLSetToExamples starts" << endl;
 #endif
-  for ( map< int, vector<NICE::Vector *> >::iterator iter = lvec.begin(); iter != lvec.end(); ++iter )
-  {
-    for ( int j = 0; j < (int)iter->second.size(); j++ )
+    for ( map< int, vector<NICE::Vector *> >::iterator iter = lvec.begin(); iter != lvec.end(); ++iter )
     {
-      NICE::Vector *vec = new NICE::Vector ( * ( iter->second[j] ) );
-      Example ex ( vec );
-      examples.push_back ( pair<int, Example> ( iter->first, ex ) );
+        for ( int j = 0; j < (int)iter->second.size(); j++ )
+        {
+            NICE::Vector *vec = new NICE::Vector ( * ( iter->second[j] ) );
+            Example ex ( vec );
+            examples.push_back ( pair<int, Example> ( iter->first, ex ) );
+        }
     }
-  }
 
-  if (!removeOldDataPointer)
-  {
-    //NOTE this is only useful, if our classifier does NOT need the data explicitely
-    lvec.clear();
-  }
-  else
-  {
-    lvec.removePointersToDataWithoutDeletion();
-    //after setting all the pointers to NULL, we can savely clear the LSet without deleting the previously
-    //stored features, which might be needed somewhere else, e.g., in the VCNearestNeighbour
-    lvec.clear();
-  }
+    if (!removeOldDataPointer)
+    {
+        //NOTE this is only useful, if our classifier does NOT need the data explicitely
+        lvec.clear();
+    }
+    else
+    {
+        lvec.removePointersToDataWithoutDeletion();
+        //after setting all the pointers to NULL, we can savely clear the LSet without deleting the previously
+        //stored features, which might be needed somewhere else, e.g., in the VCNearestNeighbour
+        lvec.clear();
+    }
 
 #ifdef DEBUG_PRINTS
-  cout << "SemSegRegionBased::convertLSetToExamples finished" << endl;
+    cout << "SemSegRegionBased::convertLSetToExamples finished" << endl;
 #endif
 }
 
 void SemanticSegmentation::convertExamplesToLSet ( Examples &examples, LabeledSetVector &lvec )
 {
 #ifdef DEBUG_PRINTS
-  cout << "SemSegRegionBased::convertExamplesToLSet starts" << endl;
+    cout << "SemSegRegionBased::convertExamplesToLSet starts" << endl;
 #endif
-  lvec.clear();
-  for ( int i = 0; i < ( int ) examples.size(); i++ )
-  {
-    if ( examples[i].second.vec != NULL )
-    {
-      lvec.add ( examples[i].first, *examples[i].second.vec );
-      delete examples[i].second.vec;
-      examples[i].second.vec = NULL;
-    }
-    else
+    lvec.clear();
+    for ( int i = 0; i < ( int ) examples.size(); i++ )
     {
-      if ( examples[i].second.svec != NULL )
-      {
-        NICE::Vector v;
-        examples[i].second.svec->convertToVectorT(v);
-        lvec.add ( examples[i].first, v );
-        delete examples[i].second.svec;
-        examples[i].second.svec = NULL;        
-      }
-      else
-      {
-        throw ( "no features for LabeledSet" );
-      }
-    }
+        if ( examples[i].second.vec != NULL )
+        {
+            lvec.add ( examples[i].first, *examples[i].second.vec );
+            delete examples[i].second.vec;
+            examples[i].second.vec = NULL;
+        }
+        else
+        {
+            if ( examples[i].second.svec != NULL )
+            {
+                NICE::Vector v;
+                examples[i].second.svec->convertToVectorT(v);
+                lvec.add ( examples[i].first, v );
+                delete examples[i].second.svec;
+                examples[i].second.svec = NULL;
+            }
+            else
+            {
+                throw ( "no features for LabeledSet" );
+            }
+        }
 
-  }
-  examples.clear();  
+    }
+    examples.clear();
 #ifdef DEBUG_PRINTS
-  cout << "SemSegRegionBased::convertExamplesToLSet finished" << endl;
+    cout << "SemSegRegionBased::convertExamplesToLSet finished" << endl;
 #endif
 }
 
 void SemanticSegmentation::convertExamplesToVVector ( VVector &feats, Examples &examples, vector<int> &label )
 {
 #ifdef DEBUG_PRINTS
-  cout << "SemSegRegionBased::convertExamplesToVVector starts" << endl;
+    cout << "SemSegRegionBased::convertExamplesToVVector starts" << endl;
 #endif
-  feats.clear();
-  label.clear();
-  for ( int i = 0; i < ( int ) examples.size(); i++ )
-  {
-    label.push_back ( examples[i].first );
-    feats.push_back ( *examples[i].second.vec );
-    delete examples[i].second.vec;
-    examples[i].second.vec = NULL;
-  }
-  examples.clear();
+    feats.clear();
+    label.clear();
+    for ( int i = 0; i < ( int ) examples.size(); i++ )
+    {
+        label.push_back ( examples[i].first );
+        feats.push_back ( *examples[i].second.vec );
+        delete examples[i].second.vec;
+        examples[i].second.vec = NULL;
+    }
+    examples.clear();
 #ifdef DEBUG_PRINTS
-  cout << "SemSegRegionBased::convertExamplesToVVector finished" << endl;
+    cout << "SemSegRegionBased::convertExamplesToVVector finished" << endl;
 #endif
 }
 
 void SemanticSegmentation::convertVVectorToExamples ( VVector &feats, Examples &examples, vector<int> &label )
 {
 #ifdef DEBUG_PRINTS
-  cout << "SemSegRegionBased::convertVVectorToExamples starts" << endl;
+    cout << "SemSegRegionBased::convertVVectorToExamples starts" << endl;
 #endif
-  for ( int i = 0; i < ( int ) feats.size(); i++ )
-  {
-    NICE::Vector *v = new NICE::Vector ( feats[i] );
-    Example ex ( v );
-    ex.position = 0; //TODO: hier mal was besseres überlegen, damit Klassifikator wieder Bildspezifisch lernt
-    examples.push_back ( pair<int, Example> ( label[i], ex ) );
-    feats[i].clear();
-  }
-  feats.clear();
-  label.clear();
+    for ( int i = 0; i < ( int ) feats.size(); i++ )
+    {
+        NICE::Vector *v = new NICE::Vector ( feats[i] );
+        Example ex ( v );
+        ex.position = 0; //TODO: hier mal was besseres überlegen, damit Klassifikator wieder Bildspezifisch lernt
+        examples.push_back ( pair<int, Example> ( label[i], ex ) );
+        feats[i].clear();
+    }
+    feats.clear();
+    label.clear();
 #ifdef DEBUG_PRINTS
-  cout << "SemSegRegionBased::convertVVectorToExamples finished" << endl;
+    cout << "SemSegRegionBased::convertVVectorToExamples finished" << endl;
 #endif
 }
 
 void SemanticSegmentation::setIterationCountSuffix( const int & _iterationCountSuffix)
 {
-  this->iterationCountSuffix = _iterationCountSuffix;
+    this->iterationCountSuffix = _iterationCountSuffix;
 }
 
 void SemanticSegmentation::setClassNames ( const OBJREC::ClassNames * _classNames )
 {
-  this->classNames = _classNames;
-}
-
-void SemanticSegmentation::make3DImage ( const std::vector<std::string> & filelist,
-    NICE::MultiChannelImage3DT<double> & imgData )
-{
-  bool isInit = false;
-  for ( int it = 0; it < ( int ) filelist.size(); it++ )
-  {
-    if ( imagetype == IMAGETYPE_RGB )
-    {
-      NICE::ColorImage img;
-      try
-      {
-        img.read ( filelist[it] );
-      }
-      catch ( ImageException iE )
-      {
-        fprintf ( stderr, "Failed to open color image file: %s\n", filelist[it].c_str() );
-        fprintf ( stderr, "%s\n", iE.what() );
-        exit ( -1 );
-      }
-      if ( !isInit )
-      {
-        imgData.reInit ( img.width(),img.height(),filelist.size(),3 );
-        isInit = true;
-      }
-      for ( int y = 0; y < img.height(); y++ )
-      {
-        for ( int x = 0; x < img.width(); x++ )
-        {
-          for ( int r = 0; r < 3; r++ )
-          {
-            imgData.set ( x, y, it, img.getPixel ( x,y,r ), r );
-          }
-        }
-      }
-    }
-    else
-    {
-      NICE::Image img;
-      try
-      {
-        img.read ( filelist[it] );
-      }
-      catch ( ImageException iE )
-      {
-        fprintf ( stderr, "Failed to open image file: %s\n", filelist[it].c_str() );
-        fprintf ( stderr, "%s\n", iE.what() );
-        exit ( -1 );
-      }
-      if ( !isInit )
-      {
-        imgData.reInit ( img.width(),img.height(),filelist.size(),1 );
-        isInit = true;
-      }
-      for ( int y = 0; y < img.height(); y++ )
-      {
-        for ( int x = 0; x < img.width(); x++ )
-        {
-          imgData.set ( x, y, it, img.getPixel ( x,y ), 0 );
-        }
-      }
-    }
-  }
-
-  if ( imagetype == IMAGETYPE_GRAY )
-  {
-    imgData.equalizeHistogram( 0 );
-#ifdef DEBUG_PRINTS
-    for (int z = 0; z < imgData.depth(); z++)
-    {
-      NICE::Image im = imgData.getChannel( z, 0);
-      im.write( filelist[z]+"_eq.pgm");
-    }
-#endif
-  }
+    this->classNames = _classNames;
 }
 
 void SemanticSegmentation::getProbabilityMap ( const NICE::MultiChannelImage3DT<double> & prob )
 {
-  std::string s;
+    std::string s;
 
-  for ( int cl = 0; cl < prob.channels(); cl++ )
-    for ( int z = 0; z < prob.depth(); z++ )
-    {
-      NICE::ColorImage img( prob.width(),prob.height() );
-      NICE::ImageT<double> m = prob.getChannelT(z, cl);
-      imageToPseudoColor(m, img);
+    for ( int cl = 0; cl < prob.channels(); cl++ )
+        for ( int z = 0; z < prob.depth(); z++ )
+        {
+            NICE::ColorImage img( prob.width(),prob.height() );
+            NICE::ImageT<double> m = prob.getChannelT(z, cl);
+            imageToPseudoColor(m, img);
 
-      std::stringstream out;
-      out << "probmap_s" << z << "_c" << cl << ".ppm";
-      s = out.str();
-      img.write( s );
+            std::stringstream out;
+            out << "probmap_s" << z << "_c" << cl << ".ppm";
+            s = out.str();
+            img.write( s );
 
-      //showImage(img, "Probability map");
-      //getchar();
-    }
+            //showImage(img, "Probability map");
+            //getchar();
+        }
 }
 
 ///////////////////// INTERFACE PERSISTENT /////////////////////
@@ -364,123 +300,123 @@ void SemanticSegmentation::getProbabilityMap ( const NICE::MultiChannelImage3DT<
 
 void SemanticSegmentation::restore ( std::istream & is, int format )
 {
-  //delete everything we knew so far...
-  this->clear();
+    //delete everything we knew so far...
+    this->clear();
 
-  bool b_restoreVerbose ( false );
+    bool b_restoreVerbose ( false );
 #ifdef B_RESTOREVERBOSE
-  b_restoreVerbose = true;
+    b_restoreVerbose = true;
 #endif
 
-  if ( is.good() )
-  {
-    if ( b_restoreVerbose )
-      std::cerr << " restore SemanticSegmentation" << std::endl;
+    if ( is.good() )
+    {
+        if ( b_restoreVerbose )
+            std::cerr << " restore SemanticSegmentation" << std::endl;
 
-    std::string tmp;
-    is >> tmp; //class name
+        std::string tmp;
+        is >> tmp; //class name
 
-    if ( ! this->isStartTag( tmp, "SemanticSegmentation" ) )
-    {
-      std::cerr << " WARNING - attempt to restore SemanticSegmentation, but start flag " << tmp << " does not match! Aborting... " << std::endl;
-      throw;
-    }
+        if ( ! this->isStartTag( tmp, "SemanticSegmentation" ) )
+        {
+            std::cerr << " WARNING - attempt to restore SemanticSegmentation, but start flag " << tmp << " does not match! Aborting... " << std::endl;
+            throw;
+        }
 
-    is.precision (numeric_limits<double>::digits10 + 1);
+        is.precision (numeric_limits<double>::digits10 + 1);
 
-    bool b_endOfBlock ( false ) ;
+        bool b_endOfBlock ( false ) ;
 
-    while ( !b_endOfBlock )
+        while ( !b_endOfBlock )
+        {
+            is >> tmp; // start of block
+
+            if ( this->isEndTag( tmp, "SemanticSegmentation" ) )
+            {
+                b_endOfBlock = true;
+                continue;
+            }
+
+            tmp = this->removeStartTag ( tmp );
+
+            if ( b_restoreVerbose )
+                std::cerr << " currently restore section " << tmp << " in SemanticSegmentation" << std::endl;
+
+            if ( tmp.compare("classNames") == 0 )
+            {
+                //dirty solution to circumvent the const-flag
+                const_cast<ClassNames*>(this->classNames)->restore ( is, format );
+
+                is >> tmp; // end of block
+                tmp = this->removeEndTag ( tmp );
+            }
+            else if ( tmp.compare("imagetype") == 0 )
+            {
+                unsigned int ui_imagetyp;
+                is >> ui_imagetyp;
+                this->imagetype = static_cast<IMAGETYP> ( ui_imagetyp );
+
+                is >> tmp; // end of block
+                tmp = this->removeEndTag ( tmp );
+            }
+            else if ( tmp.compare("iterationCountSuffix") == 0 )
+            {
+                is >> this->iterationCountSuffix;
+
+                is >> tmp; // end of block
+                tmp = this->removeEndTag ( tmp );
+            }
+            else
+            {
+                std::cerr << "WARNING -- unexpected SemanticSegmentation object -- " << tmp << " -- for restoration... aborting" << std::endl;
+                throw;
+            }
+        }
+    }
+    else
     {
-      is >> tmp; // start of block
-
-      if ( this->isEndTag( tmp, "SemanticSegmentation" ) )
-      {
-        b_endOfBlock = true;
-        continue;
-      }
-
-      tmp = this->removeStartTag ( tmp );
-
-      if ( b_restoreVerbose )
-        std::cerr << " currently restore section " << tmp << " in SemanticSegmentation" << std::endl;
-
-      if ( tmp.compare("classNames") == 0 )
-      {
-  //dirty solution to circumvent the const-flag
-        const_cast<ClassNames*>(this->classNames)->restore ( is, format );
-
-        is >> tmp; // end of block
-        tmp = this->removeEndTag ( tmp );
-      }
-      else if ( tmp.compare("imagetype") == 0 )
-      {
-        unsigned int ui_imagetyp;
-        is >> ui_imagetyp;
-        this->imagetype = static_cast<IMAGETYP> ( ui_imagetyp );
-
-        is >> tmp; // end of block
-        tmp = this->removeEndTag ( tmp );
-      }
-      else if ( tmp.compare("iterationCountSuffix") == 0 )
-      {
-        is >> this->iterationCountSuffix;
-
-        is >> tmp; // end of block
-        tmp = this->removeEndTag ( tmp );
-      }
-      else
-      {
-      std::cerr << "WARNING -- unexpected SemanticSegmentation object -- " << tmp << " -- for restoration... aborting" << std::endl;
-      throw;
-      }
+        std::cerr << "SemanticSegmentation::restore -- InStream not initialized - restoring not possible!" << std::endl;
+        throw;
     }
-  }
-  else
-  {
-    std::cerr << "SemanticSegmentation::restore -- InStream not initialized - restoring not possible!" << std::endl;
-    throw;
-  }
 
 
- //TODO check whether we also have to do something linke Preprocess::Init ( conf );
+    //TODO check whether we also have to do something linke Preprocess::Init ( conf );
 }
 
 void SemanticSegmentation::store ( std::ostream & os, int format ) const
 {
-  if (os.good())
-  {
-    // show starting point
-    os << this->createStartTag( "SemanticSegmentation" ) << std::endl;
+    if (os.good())
+    {
+        // show starting point
+        os << this->createStartTag( "SemanticSegmentation" ) << std::endl;
 
-    os.precision (numeric_limits<double>::digits10 + 1);
+        os.precision (numeric_limits<double>::digits10 + 1);
 
-    os << this->createStartTag( "classNames" ) << std::endl;
-    this->classNames->store ( os, format );
-    os << this->createEndTag( "classNames" ) << std::endl;
+        os << this->createStartTag( "classNames" ) << std::endl;
+        this->classNames->store ( os, format );
+        os << this->createEndTag( "classNames" ) << std::endl;
 
-    //
+        //
 
-    os << this->createStartTag( "imagetype" ) << std::endl;
-    os << imagetype << std::endl;
-    os << this->createEndTag( "imagetype" ) << std::endl;
+        os << this->createStartTag( "imagetype" ) << std::endl;
+        os << imagetype << std::endl;
+        os << this->createEndTag( "imagetype" ) << std::endl;
 
-    //
+        //
 
-    os << this->createStartTag( "iterationCountSuffix" ) << std::endl;
-    os << iterationCountSuffix << std::endl;
-    os << this->createEndTag( "iterationCountSuffix" ) << std::endl;
+        os << this->createStartTag( "iterationCountSuffix" ) << std::endl;
+        os << iterationCountSuffix << std::endl;
+        os << this->createEndTag( "iterationCountSuffix" ) << std::endl;
 
-    // done
-    os << this->createEndTag( "SemanticSegmentation" ) << std::endl;
-  }
-  else
-  {
-    std::cerr << "OutStream not initialized - storing not possible!" << std::endl;
-  }
+        // done
+        os << this->createEndTag( "SemanticSegmentation" ) << std::endl;
+    }
+    else
+    {
+        std::cerr << "OutStream not initialized - storing not possible!" << std::endl;
+    }
 }
 
 void SemanticSegmentation::clear ()
 {
- //TODO
+    //TODO
 }

semseg/SemanticSegmentation.h

@@ -110,6 +110,16 @@ class SemanticSegmentation : public NICE::Persistent
                        NICE::ImageT<int> & segresult,
                        NICE::MultiChannelImageT<double> & probabilities );
 
+    /**
+     * @brief Pre-processing and classification of a 3D image
+     * @param filelist filename list of images that represent slices of a stack
+     * @param segresult segmentation results (output)
+     * @param probabilities probabilities for each pixel (output)
+     */
+    void semanticseg ( const std::vector<std::string> & filelist,
+                       NICE::MultiChannelImageT<int> & segresult,
+                       NICE::MultiChannelImage3DT<double> & probabilities );
+
     /**
      * Classify each voxel of a 3D image (image stack)
      * @author Sven Sickert
@@ -132,6 +142,17 @@ class SemanticSegmentation : public NICE::Persistent
                                NICE::ImageT<int> & segresult,
                                NICE::MultiChannelImageT<double> & probabilities ) = 0;
 
+    /**
+     * Classify each voxel of a 3D image (image stack)
+     * @author Sven Sickert
+     * @param ce 3d image data
+     * @param segresult segmentation results (output)
+     * @param probabilities probabilities for each pixel (output)
+     */
+    virtual void semanticseg ( OBJREC::CachedExample *ce,
+                               NICE::MultiChannelImageT<int> & segresult,
+                               NICE::MultiChannelImage3DT<double> & probabilities ) = 0;
+
 
     /** training function (has to be overloaded by all subclasses)
      * @param md the data set
@@ -150,8 +171,9 @@ class SemanticSegmentation : public NICE::Persistent
      * @param filelist filename list of images that represent slices of a stack
      * @param imgData output
      */
+    template<class SrcP>
     void make3DImage ( const std::vector<std::string> & filelist,
-                       NICE::MultiChannelImage3DT<double> & imgData );
+                       NICE::MultiChannelImage3DT<SrcP> & imgData );
 
 
     ///////////////////// ///////////////////// /////////////////////
@@ -243,4 +265,6 @@ class SemanticSegmentation : public NICE::Persistent
 
 } // namespace
 
+#include "SemanticSegmentation.tcc"
+
 #endif

semseg/SemanticSegmentation.tcc

@@ -0,0 +1,77 @@
+#include <stdio.h>
+#include <vector>
+
+namespace OBJREC {
+
+template<class SrcP>
+void SemanticSegmentation::make3DImage ( const std::vector<std::string> & filelist,
+                                         NICE::MultiChannelImage3DT<SrcP> & imgData )
+{
+    bool isInit = false;
+    for ( int it = 0; it < ( int ) filelist.size(); it++ )
+    {
+        if ( imagetype == IMAGETYPE_RGB )
+        {
+            NICE::ColorImage img;
+            try
+            {
+                img.read ( filelist[it] );
+            }
+            catch ( NICE::ImageException iE )
+            {
+                fprintf ( stderr, "Failed to open color image file: %s\n", filelist[it].c_str() );
+                fprintf ( stderr, "%s\n", iE.what() );
+                exit ( -1 );
+            }
+            if ( !isInit )
+            {
+                imgData.reInit ( img.width(),img.height(),filelist.size(),3 );
+                isInit = true;
+            }
+            for ( int y = 0; y < img.height(); y++ )
+            {
+                for ( int x = 0; x < img.width(); x++ )
+                {
+                    for ( int r = 0; r < 3; r++ )
+                    {
+                        imgData.set ( x, y, it, (SrcP)img.getPixel ( x,y,r ), r );
+                    }
+                }
+            }
+        }
+        else
+        {
+            NICE::Image img;
+            try
+            {
+                img.read ( filelist[it] );
+            }
+            catch ( NICE::ImageException iE )
+            {
+                fprintf ( stderr, "Failed to open image file: %s\n", filelist[it].c_str() );
+                fprintf ( stderr, "%s\n", iE.what() );
+                exit ( -1 );
+            }
+            if ( !isInit )
+            {
+                imgData.reInit ( img.width(),img.height(),filelist.size(),1 );
+                isInit = true;
+            }
+            for ( int y = 0; y < img.height(); y++ )
+            {
+                for ( int x = 0; x < img.width(); x++ )
+                {
+                    imgData.set ( x, y, it, (SrcP)img.getPixel ( x,y ), 0 );
+                }
+            }
+        }
+    }
+
+    if ( imagetype == IMAGETYPE_GRAY )
+    {
+        imgData.equalizeHistogram( 0 );
+    }
+
+}
+
+}