Ignore:
Timestamp:
14 Sep 2015, 19:41:29 (9 years ago)
Author:
tech
Message:

Integrated general SEI changes and following SEIs:

  • Multiview view position SEI
  • Multiview acquisition information SEI
  • Multiview scene information SEI
  • Inter-layer constrained tile sets SEI
File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/HTM-15.1-dev0/source/Lib/TAppCommon/program_options_lite.h

    r1313 r1328  
    7878    struct ErrorReporter
    7979    {
     80#if NH_MV_SEI
     81      ErrorReporter() : is_errored(0), output_on_unknow_parameter(true)  {}
     82#else
    8083      ErrorReporter() : is_errored(0) {}
     84#endif
    8185      virtual ~ErrorReporter() {}
    8286      virtual std::ostream& error(const std::string& where);
    8387      virtual std::ostream& warn(const std::string& where);
    8488      bool is_errored;
     89#if NH_MV_SEI
     90      bool output_on_unknow_parameter;
     91#endif
    8592    };
    8693
     
    98105    {
    99106#if NH_MV     
     107#if NH_MV_SEI     
     108      OptionBase(const std::string& name, const std::string& desc, bool duplicate = false, std::vector< int > maxdim = std::vector< int >(0) )
     109        : opt_string(name), opt_desc(desc), opt_duplicate(duplicate), max_dim( maxdim )
     110#else
    100111      OptionBase(const std::string& name, const std::string& desc, bool duplicate = false)
    101112        : opt_string(name), opt_desc(desc), opt_duplicate(duplicate)
     113#endif
    102114#else
    103115      OptionBase(const std::string& name, const std::string& desc)
     
    109121
    110122      /* parse argument arg, to obtain a value for the option */
     123#if NH_MV_SEI
     124      virtual void parse(const std::string& arg, const std::vector<int>& idcs,  ErrorReporter&) = 0;
     125     
     126      bool   checkDim( std::vector< int > dims, ErrorReporter& err )
     127      {     
     128        bool doParsing = true;
     129        if ( dims.size() != max_dim.size() )
     130        {
     131            err.error(" ") << "Number of indices of `" <<  opt_string << "' not matching. Should be " << max_dim.size() << std::endl;
     132            doParsing = false;
     133        }
     134
     135        for (size_t i = 0 ; i < dims.size(); i++ )
     136        {
     137          if ( dims[i] >= max_dim[i] )
     138          {
     139            if (err.output_on_unknow_parameter )
     140            {       
     141              err.warn(" ") << "Index " << i  << " of  " <<  opt_string << " should be less than " << max_dim[i] << std::endl;             
     142              doParsing = false;
     143            }
     144          }
     145        }
     146        return doParsing;
     147      }
     148
     149      void   xParseVec( const std::string& arg, BoolAry1d& storage )
     150      {       
     151        char* pcNextStart = (char*) arg.data();
     152        char* pcEnd = pcNextStart + arg.length();
     153
     154        char* pcOldStart = 0;
     155
     156        size_t iIdx = 0;
     157
     158        while (pcNextStart < pcEnd)
     159        {
     160          if ( iIdx < storage.size() )
     161          {
     162            storage[iIdx] = (strtol(pcNextStart, &pcNextStart,10) != 0);
     163          }
     164          else
     165          {
     166            storage.push_back(strtol(pcNextStart, &pcNextStart,10) != 0) ;
     167          }
     168          iIdx++;
     169
     170          if ( errno == ERANGE || (pcNextStart == pcOldStart) )
     171          {
     172            std::cerr << "Error Parsing Bools: `" << arg << "'" << std::endl;
     173            exit(EXIT_FAILURE);
     174          };   
     175          while( (pcNextStart < pcEnd) && ( *pcNextStart == ' ' || *pcNextStart == '\t' || *pcNextStart == '\r' ) ) pcNextStart++; 
     176          pcOldStart = pcNextStart;
     177        }
     178      }
     179
     180      void   xParseVec( const std::string& arg, IntAry1d& storage )
     181      {       
     182        storage.clear();
     183
     184        char* pcNextStart = (char*) arg.data();
     185        char* pcEnd = pcNextStart + arg.length();
     186
     187        char* pcOldStart = 0;
     188
     189        size_t iIdx = 0;
     190
     191
     192        while (pcNextStart < pcEnd)
     193        {
     194
     195          if ( iIdx < storage.size() )
     196          {
     197            storage[iIdx] = (int) strtol(pcNextStart, &pcNextStart,10);
     198          }
     199          else
     200          {
     201            storage.push_back( (int) strtol(pcNextStart, &pcNextStart,10)) ;
     202          }
     203          iIdx++;
     204          if ( errno == ERANGE || (pcNextStart == pcOldStart) )
     205          {
     206            std::cerr << "Error Parsing Integers: `" << arg << "'" << std::endl;
     207            exit(EXIT_FAILURE);
     208          };   
     209          while( (pcNextStart < pcEnd) && ( *pcNextStart == ' ' || *pcNextStart == '\t' || *pcNextStart == '\r' ) ) pcNextStart++; 
     210          pcOldStart = pcNextStart;
     211        }     
     212      }
     213#else
    111214      virtual void parse(const std::string& arg, ErrorReporter&) = 0;
     215#endif
    112216      /* set the argument to the default value */
    113217      virtual void setDefault() = 0;
     
    117221#if NH_MV
    118222      bool        opt_duplicate;
     223#if NH_MV_SEI
     224      std::vector<int> max_dim;
     225#endif
    119226#endif
    120227    };
     
    125232    {
    126233#if NH_MV
     234#if NH_MV_SEI
     235      Option(const std::string& name, T& storage, T default_val, const std::string& desc, bool duplicate = false, std::vector< int > maxdim = std::vector< int >(0) )
     236        : OptionBase(name, desc, duplicate, maxdim), opt_storage(storage), opt_default_val(default_val)
     237#else
    127238      Option(const std::string& name, T& storage, T default_val, const std::string& desc, bool duplicate = false)
    128239        : OptionBase(name, desc, duplicate), opt_storage(storage), opt_default_val(default_val)
     240#endif
    129241#else
    130242      Option(const std::string& name, T& storage, T default_val, const std::string& desc)
     
    133245      {}
    134246
     247#if NH_MV_SEI
     248      void parse(const std::string& arg, const std::vector<int>& idcs, ErrorReporter&);
     249#else
    135250      void parse(const std::string& arg, ErrorReporter&);
     251#endif
    136252
    137253      void setDefault()
     
    147263    template<typename T>
    148264    inline void
     265#if NH_MV_SEI
     266    Option<T>::parse(const std::string& arg, const std::vector<int>& idcs, ErrorReporter&)
     267#else
    149268    Option<T>::parse(const std::string& arg, ErrorReporter&)
    150     {
     269#endif
     270    {
     271#if NH_MV_SEI
     272      assert( idcs.size() == 0 );
     273#endif
     274     
    151275      std::istringstream arg_ss (arg,std::istringstream::in);
    152276      arg_ss.exceptions(std::ios::failbit);
     
    165289    template<>
    166290    inline void
     291#if NH_MV_SEI
     292    Option<std::string>::parse(const std::string& arg, const std::vector<int>& idcs, ErrorReporter&)
     293#else
    167294    Option<std::string>::parse(const std::string& arg, ErrorReporter&)
    168     {
     295#endif
     296    {
     297#if NH_MV_SEI
     298      assert( idcs.size() == 0 );
     299#endif
    169300      opt_storage = arg;
    170301    }
     
    173304    template<>
    174305    inline void
     306#if NH_MV_SEI
     307      Option<char*>::parse(const std::string& arg, const std::vector<int>& idcs, ErrorReporter&)
     308#else
    175309      Option<char*>::parse(const std::string& arg, ErrorReporter&)
    176     {
     310#endif
     311    {
     312#if NH_MV_SEI
     313      assert( idcs.size() == 0 );
     314#endif
    177315      opt_storage = arg.empty() ? NULL : strdup(arg.c_str()) ;
    178316    }
     317
     318#if !NH_MV_SEI
    179319
    180320    template<>
     
    198338      }     
    199339    }
    200 
     340#endif
    201341
    202342    template<>   
    203343    inline void
     344#if NH_MV_SEI
     345      Option< std::vector<double> >::parse(const std::string& arg, const std::vector< int > & idcs, ErrorReporter&)
     346#else
    204347      Option< std::vector<double> >::parse(const std::string& arg, ErrorReporter&)
    205     {
     348#endif
     349    {
     350#if NH_MV_SEI
     351      assert( idcs.size() == 0 );
     352#endif
    206353      char* pcNextStart = (char*) arg.data();
    207354      char* pcEnd = pcNextStart + arg.length();
     
    236383    }
    237384
     385
     386#if NH_MV_SEI
     387    template<>
     388    inline void
     389      Option< IntAry1d >::parse(const std::string& arg, const IntAry1d& idcs, ErrorReporter& err)
     390    {
     391      xParseVec( arg, opt_storage );
     392    };
     393
     394    template<>
     395    inline void
     396      Option< IntAry2d >::parse(const std::string& arg, const IntAry1d& idcs, ErrorReporter&)
     397    {
     398      xParseVec( arg, opt_storage[ idcs[0] ] );
     399    };
     400
     401    template<>
     402    inline void
     403      Option< IntAry3d >::parse(const std::string& arg, const IntAry1d& idcs, ErrorReporter&)
     404    {
     405      xParseVec ( arg, opt_storage[ idcs[0] ][ idcs[1] ] );
     406    };
     407#else
    238408    template<>
    239409    inline void
     
    272442      }
    273443    }
    274 
    275 
     444#endif
     445
     446#if NH_MV_SEI
     447
     448    template<>
     449    inline void
     450      Option< std::vector< char*>  >::parse(const std::string& arg, const std::vector<int>& idcs, ErrorReporter& err )
     451    {
     452     
     453      opt_storage[ idcs[ 0 ] ] = arg.empty() ? NULL : strdup(arg.c_str()) ;
     454    };
     455
     456    template<>
     457    inline void
     458      Option< BoolAry1d >::parse(const std::string& arg, const std::vector<int>& idcs, ErrorReporter& err)
     459    {     
     460      xParseVec( arg, opt_storage );
     461    };
     462
     463    template<>
     464    inline void
     465      Option< BoolAry2d >::parse(const std::string& arg, const IntAry1d& idcs, ErrorReporter& err)
     466    {     
     467      xParseVec( arg, opt_storage[ idcs[0] ] );
     468    };
     469
     470    template<>
     471    inline void
     472      Option< BoolAry3d >::parse(const std::string& arg, const IntAry1d& idcs, ErrorReporter& err )
     473    {     
     474      xParseVec( arg, opt_storage[idcs[0]][idcs[1]] );
     475    };
     476#else
    276477    template<>
    277478    inline void
     
    307508    }
    308509#endif
     510#endif
    309511    /** Option class for argument handling using a user provided function */
    310512    struct OptionFunc : public OptionBase
     
    316518      {}
    317519
     520#if NH_MV_SEI
     521      void parse(const std::string& arg, const std::vector<int>& idcs, ErrorReporter& error_reporter)
     522#else
    318523      void parse(const std::string& arg, ErrorReporter& error_reporter)
     524#endif
    319525      {
    320526        func(parent, arg, error_reporter);
     
    388594        operator()(const std::string& name, std::vector<T>& storage, T default_val, unsigned uiMaxNum, const std::string& desc = "" )
    389595      {
     596#if NH_MV_SEI
     597        std::vector<T> defVal;
     598        defVal.resize( uiMaxNum, default_val );
     599        std::vector< int > maxSize;
     600        maxSize.push_back( uiMaxNum );
     601        parent.addOption(new Option< std::vector<T> >( name, storage, defVal, desc, false, maxSize ));
     602
     603        return *this;
     604      }
     605      template<typename T>
     606      OptionSpecific&
     607        operator()(const std::string& name, std::vector< std::vector<T> >& storage, T default_val, unsigned uiMaxNumDim1, unsigned uiMaxNumDim2, const std::string& desc = "" )
     608      {
     609        std::vector< std::vector<T> > defVal;
     610        defVal.resize(uiMaxNumDim1);
     611        for ( unsigned int idxDim1 = 0; idxDim1 < uiMaxNumDim1; idxDim1++ )
     612        {
     613          defVal[ idxDim1 ].resize(uiMaxNumDim2, default_val );         
     614        }
     615
     616        std::vector< int > maxSize;
     617        maxSize.push_back( uiMaxNumDim1 );
     618        maxSize.push_back( uiMaxNumDim2 );
     619
     620        parent.addOption(new Option< std::vector< std::vector<T> > >( name, storage, defVal, desc, false, maxSize ));
     621        return *this;
     622      }
     623#else
    390624        std::string cNameBuffer;
    391625        std::string cDescBuffer;
     
    415649        return *this;
    416650      }
     651#endif
    417652#endif
    418653      /**
Note: See TracChangeset for help on using the changeset viewer.