NICE_SemSeg/semseg/SemanticSegmentation.h

/**
* @file SemanticSegmentation.h
* @brief abstract interface for semantic segmentation algorithms
* @author Erik Rodner, Alexander Freytag
* @date 03/19/2009, latest update: 29-01-2014 (dd-mm-yyyy)

*/
#ifndef SEMANTICSEGMENTATIONINCLUDE
#define SEMANTICSEGMENTATIONINCLUDE

// nice-core includes
#include <core/basics/Persistent.h>

// nice-vislearning includes
#include <vislearning/cbaselib/MultiDataset.h>
#include <vislearning/cbaselib/LocalizationResult.h>
#include <vislearning/cbaselib/CachedExample.h>
#include <vislearning/cbaselib/Example.h>


#define ROADWORKSADD fthrow(NICE::Exception, "addNewExample(const NICE::Vector & newExample, const int & newClassNo): not yet implemented!");
#define ROADWORKSADDNOVEL fthrow(NICE::Exception, "addNovelExamples(): not yet implemented!");
#define ROADWORKSGETNOVEL fthrow(NICE::Exception, "getNovelExamples(): not yet implemented!");


namespace OBJREC
{

/** abstract interface for semantic segmentation algorithms */
class SemanticSegmentation : public NICE::Persistent
{

  protected:
    
    /////////////////////////
    /////////////////////////
    // PROTECTED VARIABLES //
    /////////////////////////
    ///////////////////////// 
    
    /** accessible class names and information about
        number of classes etc. */
     const ClassNames * classNames;

    /** enum type for imagetype */
    enum IMAGETYP
    {
      IMAGETYPE_RGB = 0,
      IMAGETYPE_GRAY
    };

    /** whether to load images with color information */
    IMAGETYP imagetype;
    
    int iterationCountSuffix;
    
    /////////////////////////
    /////////////////////////
    //  PROTECTED METHODS  //
    /////////////////////////
    /////////////////////////    

  public:
    
    ///////////////////// ///////////////////// /////////////////////
    //                   CONSTRUCTORS / DESTRUCTORS
    ///////////////////// ///////////////////// /////////////////////     

    /** default constructor
     * @author Alexander Freytag
     * @date 06-02-2014 ( dd-mm-yyy )
    */
    SemanticSegmentation ( );    
    
    /** simple constructor
        @param conf global settings
        @param classNames this ClassNames object while be stored as a attribute
    */
    SemanticSegmentation ( const NICE::Config *conf,
                           const ClassNames *classNames );

    /** simple destructor */
    virtual ~SemanticSegmentation();
    
    /** 
    * @brief Setup internal variables and objects used
    * @author Alexander Freytag
    * @param conf Config file to specify variable settings
    * @param s_confSection
    */    
    void initFromConfig(const NICE::Config *conf, const std::string & s_confSection = "SemanticSegmentation");  
    
    ///////////////////// ///////////////////// /////////////////////
    //                      SEGMENTATION STUFF
    ///////////////////// ///////////////////// /////////////////////      

    /** load img from file call localize(CachedExample *ce) etc. */
    void semanticseg ( const std::string & filename,
                       NICE::Image & segresult,
                       NICE::MultiChannelImageT<double> & probabilities );    

    /** this function has to be overloaded by all subclasses
        @param ce image data
        @param segresult result of the semantic segmentation with a label for each
        pixel
        @param probabilities multi-channel image with one channel for each class and
               corresponding probabilities for each pixel
    */
    virtual void semanticseg ( OBJREC::CachedExample *ce,
                               NICE::Image & segresult,
                               NICE::MultiChannelImageT<double> & probabilities ) = 0;

                               
    ///////////////////// ///////////////////// /////////////////////
    //                      DATA CONVERSION
    ///////////////////// ///////////////////// /////////////////////                                
    /**
     * convert different datatypes
     */
    void convertVVectorToExamples ( NICE::VVector &feats,OBJREC::Examples &examples, std::vector<int> &label );
    void convertExamplesToVVector ( NICE::VVector &feats,OBJREC::Examples &examples, std::vector<int> &label );
    void convertExamplesToLSet ( OBJREC::Examples &examples, OBJREC::LabeledSetVector &lvec );
    void convertLSetToExamples ( OBJREC::Examples &examples, OBJREC::LabeledSetVector &lvec, const bool & removeOldDataPointer=false );
    void convertLSetToSparseExamples ( OBJREC::Examples &examples, OBJREC::LabeledSetVector &lvec );

    

    
    ///////////////////// ///////////////////// /////////////////////
    //                       ONLINE LEARNING
    ///////////////////// ///////////////////// /////////////////////      
    
    virtual void addNewExample(const NICE::Vector & newExample, const int & newClassNo)
    {
      ROADWORKSADD;      
    };
    /**
     * @brief Add those examples, which belong to the most novel region seen so far
     *
     * @return void
     **/    
    virtual void addNovelExamples()
    {
      ROADWORKSADDNOVEL;      
    };   
    
    ///////////////////// ///////////////////// /////////////////////
    //                         GET / SET
    ///////////////////// ///////////////////// /////////////////////      
    
    /**
     * @brief Get a pointer to the examples extracted from the most novel region seen so far
     *
     * @return Examples *
     **/        
    virtual const Examples * getNovelExamples() const
    {
      ROADWORKSGETNOVEL;      
    };
    
    /**
     * @author Alexander Freytag
     * @date 06-02-2014 ( dd-mm-yyyy )
     */
    void setClassNames ( const OBJREC::ClassNames * _classNames  ) ;
    
    void setIterationCountSuffix( const int & _iterationCountSuffix);
    
    ///////////////////// INTERFACE PERSISTENT /////////////////////
    // interface specific methods for store and restore
    ///////////////////// INTERFACE PERSISTENT /////////////////////   
    
    /** 
     * @brief Load active-segmentation-object from external file (stream)
     * @author Alexander Freytag
     */     
    virtual void restore ( std::istream & is, int format = 0 );
    
    /** 
     * @brief Save active-segmentation-object to external file (stream)
     * @author Alexander Freytag
     */       
    virtual void store( std::ostream & os, int format = 0 ) const;
    
    /** 
     * @brief Clear active-segmentation-object object
     * @author Alexander Freytag
     */    
    virtual void clear ();    
    
    

};


} // namespace

#endif