ParamTypes.hh

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
Multimediale Systeme der Informationsverarbeitung
Institut fuer Informatik
Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifndef __ParamTypes_hh__
#define __ParamTypes_hh__

#include <Base/Common/BIASpragmaStart.hh>

#include <Base/Debug/Error.hh>
#include <Base/Math/Vector.hh>
#include <Base/Common/FileHandling.hh> //< for lowercase


#include <string>
#include <sstream>
#include <map>


namespace BIAS {
    // fwd declaratiion
    class BIASUtils_EXPORT ParamCallbackInterface;

    /** @class ParamTypeBase
     *  @brief This file holds the definitions of the parameter types used by BIAS::Param.
     *  @author mdunda 03 2004
     *  @ingroup g_utils
     */
    class BIASUtils_EXPORT ParamTypeBase
    {
    public:
        // destructor
        virtual ~ParamTypeBase();

        // constructors
        ParamTypeBase();

        virtual void SetDefault(){ /* to be overwritten in derived class */ }

        /**
        This is a common interface to let a specialized instance read
        its data from a string. Used from ParseCommandLine() and ReadParam()
        to be overwritten in derived class
        */
        virtual int SetFromString(const std::string &s);

        virtual std::string GetTypeName(){return "NOTYPE";};
        virtual std::string GetValueString(){return "NOVAL";};
        virtual std::string GetHint(){return "NOVAL";};

        // data members / entries
        std::string Name_;
        std::string Help_;
        char        ShortCmd_;
        bool        WriteToFile_; ///< is only written to parameter file if true
        bool        Enhanced_; ///< hide this parameter from the 'naive' user
        bool        Hidden_; ///< hide this parameter from all users
        int         Group_;

        /// if some one changed a parameter, we should call
        /// CallbackObject_->ParameterChanged(Name_);
        ParamCallbackInterface *CallbackObject_;
    };


    // derived parameter types following...

    // =========================
    // ===      BOOLEAN      ===
    // =========================
    class BIASUtils_EXPORT ParamTypeBool : public ParamTypeBase
    {
    public:
        // 'structors
        ParamTypeBool()
          : ParamTypeBase()
        {}

        virtual ~ParamTypeBool()
        {}

        // entries
        bool value_;
        bool default_;

        /// resets to default value
        inline void SetDefault(){ value_=default_; }

        virtual int SetFromString(const std::string &s)
        {
          // be case insensitive, don't construct expression for easier debugging
          if ((FileHandling::LowerCase(s) == "true" || FileHandling::LowerCase(s) == "=true"))
            value_ = true;
          else if ((FileHandling::LowerCase(s) == "on")||(FileHandling::LowerCase(s) == "=on"))
            value_ = true;
          else if ((s=="1") || (s=="=1"))
            value_ = true;
          else
            value_ = false;

          return 0; //< OK
        };

        virtual std::string GetTypeName(){return "BOOL";};
        virtual std::string GetValueString(){return value_?"true":"false";};
        virtual std::string GetHint(){return "true / false";};
    };


    // =========================
    // ===      INTEGER      ===
    // =========================
    class BIASUtils_EXPORT ParamTypeInt : public ParamTypeBase
    {
    public:
        // 'structors
        ParamTypeInt()
            : ParamTypeBase()
        {}

        virtual ~ParamTypeInt()
        {}

        // entries
        int value_;
        int default_;
        int min_;
        int max_;
        /// resets to default value
        inline void SetDefault(){ value_=default_; }
        virtual int SetFromString(const std::string &s){
            int newval = atoi(s.c_str());
            if ( newval < min_ ){
                BIASWARN("Value for '"<<Name_<<"' clipped to "<<min_<<std::endl);
                value_ = min_;
            }
            else if (newval > max_ ) {
                BIASWARN("Value for '"<<Name_<<"' clipped to "<<max_<<std::endl);
                value_ = max_;
            }
            else value_ = newval;
            return 0;
        };
        virtual std::string GetTypeName(){return "INT";};

        virtual std::string GetValueString()
        {
            std::ostringstream oss;oss<<value_; return oss.str();
        };

        virtual std::string GetHint()
        {
            std::ostringstream oss;oss<<"[ "<<min_<<" .. "<<max_<<" ]";
            return oss.str();
        };

    }; // class ParamTypeInt


    // =========================
    // ===      DOUBLE       ===
    // =========================
    class BIASUtils_EXPORT ParamTypeDouble : public ParamTypeBase
    {
    public:
        // 'structors
        ParamTypeDouble(){}
        virtual ~ParamTypeDouble(){}
        // entries
        double value_;
        double default_;
        double min_;
        double max_;
        /// resets to default value
        inline void SetDefault(){ value_=default_; }
        virtual int SetFromString(const std::string &s){
            double newval = atof(s.c_str());
            if ( newval < min_ ){
                BIASWARN("Value for '"<<Name_<<"' clipped to "<<min_<<std::endl);
                value_ = min_;
            }
            else if (newval > max_ ) {
                BIASWARN("Value for '"<<Name_<<"' clipped to "<<max_<<std::endl);
                value_ = max_;
            }
            else value_ = newval;
            return 0;
        };
        virtual std::string GetTypeName(){return "DOUBLE";};
        virtual std::string GetValueString(){
            std::ostringstream oss;oss<<value_; return oss.str();};
            virtual std::string GetHint(){
                std::ostringstream oss;oss<<"[ "<<min_<<" .. "<<max_<<" ]";
                return oss.str();};
    };


    // =========================
    // ===      STRING       ===
    // =========================
    class BIASUtils_EXPORT ParamTypeString : public ParamTypeBase
    {
    public:
        // 'structors
        ParamTypeString(){}
        virtual ~ParamTypeString(){}
        // entries
        std::string value_;
        std::string default_;
        /// resets to default value
        inline void SetDefault(){ value_=default_; }
        virtual int SetFromString(const std::string &s){
            value_ = s;
            return 0;
        }
        virtual std::string GetTypeName(){return "STRING";};
        virtual std::string GetValueString(){return "\""+value_+"\"";};
        virtual std::string GetHint(){
            std::ostringstream oss;oss<<" def: "<<default_;
            return oss.str();};
    };


    // =========================
    // === VECTOR OF DOUBLE  ===
    // =========================
    class BIASUtils_EXPORT ParamTypeVecDbl : public ParamTypeBase
    {
    public:
        // 'structors
        ParamTypeVecDbl(){}
        virtual ~ParamTypeVecDbl(){}
        // entries
        BIAS::Vector<double> value_;
        BIAS::Vector<double> default_;
        /// resets to default value
        inline void SetDefault(){ value_=default_; }
        virtual int SetFromString(const std::string &s){
            std::istringstream iss(s);
            double x;
            // check for size
            int length=-1;
            while (iss){
                iss >> x; length++;
            }
            //std::cerr << Name_ << " has size "<<length<<std::endl;
            // resize vector
            value_.newsize(length);
            // now read it
            std::istringstream iss2(s);
            for(unsigned int i=0; i<value_.Size(); i++) {
                iss2 >> x; value_[i] = x;
                //std::cerr << x << "   ";
            }
            return 0;
        };
        virtual std::string GetTypeName(){return "VECDBL";};
        virtual std::string GetValueString(){
            std::ostringstream oss; oss<<"\"";
            for (int i=0;i<value_.size(); i++) {
                oss<<value_[i];
                if (i<value_.size()-1) oss <<" ";
            }
            oss<<"\"";
            return oss.str();
        };

    };


    // =========================
    // === VECTOR OF INTEGER ===
    // =========================
    class BIASUtils_EXPORT ParamTypeVecInt : public ParamTypeBase
    {
    public:
        // 'structors
        ParamTypeVecInt(){}
        virtual ~ParamTypeVecInt(){}
        // entries
        BIAS::Vector<int> value_;
        BIAS::Vector<int> default_;
        /// resets to default value
        inline void SetDefault(){ value_=default_; }
        virtual int SetFromString(const std::string &s){
            std::istringstream iss(s);
            int x;
            // check for size
            int length=-1;
            while (iss){
                iss >> x; length++;
            }
            //std::cerr << Name_ << " has size "<<length<<std::endl;
            // resize vector
            value_.newsize(length);
            // now read it
            std::istringstream iss2(s);
            for(unsigned int i=0; i<value_.Size(); i++) {
                iss2 >> x; value_[i] = x;
            }
            return 0;
        };
        virtual std::string GetTypeName(){return "VECINT";};
        virtual std::string GetValueString(){
            std::ostringstream oss; oss<<"\"";
            for (int i=0;i<value_.size(); i++) {
                oss<<value_[i];
                if (i<value_.size()-1) oss <<" ";
            }
            oss<<"\"";
            return oss.str();
        };

    };


    // =========================
    // ===       ENUM        ===
    // =========================
    class BIASUtils_EXPORT ParamTypeEnum : public ParamTypeBase
    {
    public:
        // 'structors
        ParamTypeEnum(){}
        virtual ~ParamTypeEnum(){}
        // entries
        int value_;
        int default_;
        std::map<std::string,int> Map_;
        /// resets to default value
        inline void SetDefault(){ value_=default_; }
        virtual int SetFromString(const std::string &s){
            std::map<std::string,int>::iterator it;
            if ( (it=Map_.find(s)) ==Map_.end() ) {
                BIASERR("Identifier for '" <<Name_<< "' is not valid. Using default.")
                    value_ = default_;
            }
            else value_ = it->second;
            return 0;
        }
        virtual std::string GetTypeName(){return "ENUM";};
        virtual std::string GetValueString(){
            std::ostringstream oss;
            std::map<std::string,int>::iterator it;
            for (it=Map_.begin();it!=Map_.end(); it++)
                if ( it->second == value_ ) oss<<it->first;
            return oss.str();};

            virtual std::string GetHint(){
                std::ostringstream oss;
                std::map<std::string,int>::iterator it;
                for (it=Map_.begin();it!=Map_.end(); it++){
                    if (it!=Map_.begin()) oss<<", ";
                    oss<<it->first;
                }
                return oss.str();};
    };
} // namespace BIAS


#include <Base/Common/BIASpragmaEnd.hh>
#endif /* __ParamTypes_hh__ */