ValueScaling.h

/*
 
MIT License
 
Copyright (c) 2017 FMI Open Development / Markus Peura, first.last@fmi.fi
 
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
 
*/
/*
Part of Rack development has been done in the BALTRAD projects part-financed
by the European Union (European Regional Development Fund and European
Neighbourhood Partnership Instrument, Baltic Sea Region Programme 2007-2013)
*/
#ifndef IMAGE_SCALING2_H_
#define IMAGE_SCALING2_H_ "ImageScaling 0.1,  2017/09 Markus.Peura@fmi.fi"
 
#include <drain/Type.h>
#include <drain/TypeUtils.h>
#include <drain/UniTuple.h>
#include <stddef.h>  // size_t
 
#include "Range.h"
 
//#include "Geometry.h"
//#include "Coordinates.h"
 
 
namespace drain
{
 
 
//extern drain::Log iLog;
 
// If the intensities of the image correspond to a physical value (like temperature), this is the recommended way to copy.
 
 
class ValueScaling : public UniTuple<double,2> {  // UniTuple<double,4>{
public:
 
    double & scale;
 
    double & offset;
 
    drain::Range<double> physRange;
 
 
    inline
    ValueScaling(double scale=1.0, double offset = 0.0) : // RANGE ok? double scaleOut=1.0, double offsetOut=0.0) :
        scale(this->next()), offset(this->next()) //, physRange(this->tuple(), 2)
    {
        //setConversionScale(scale, offset, scaleOut, offsetOut);
        setConversionScale(scale, offset, 1.0, 0);
        physRange.set(0,0);
    };
 
    inline
    ValueScaling(double scale, double offset, const drain::Range<double> & range) : //, double scaleOut=1.0, double offsetOut=0.0) :
        scale(this->next()), offset(this->next()) //, physRange(this->tuple(), 2)
    {
        //setConversionScale(scale, offset, scaleOut, offsetOut);
        setConversionScale(scale, offset, 1.0, 0);
        physRange.set(range); // TODO tune: scaleOut, offsetOut
    };
 
    inline
    ValueScaling(const drain::ValueScaling & scaling) :
        scale(this->next()), offset(this->next()) //, physRange(this->tuple(), 2)
    {
        this->assignSequence(scaling);
        physRange.set(scaling.physRange);
    };
 
    //
    inline
    ValueScaling(const drain::UniTuple<double,2> & scaling) :
        scale(this->next()), offset(this->next())
    {
        setScaling(scaling[0], scaling[1]);
    };
 
 
    // Conversion scaling
    inline
    ValueScaling(const drain::ValueScaling & scalingIn, const drain::ValueScaling & scalingOut) :
        scale(this->next()), offset(this->next())
    {
        setConversionScale(scalingIn, scalingOut);
        // physRange??? intersection / union
    };
 
    virtual inline
    ~ValueScaling(){};
 
 
    inline
    ValueScaling & operator=(const drain::ValueScaling & scaling){
        if (&scaling != this){
            this->assignSequence(scaling);
            physRange.set(scaling.physRange);
        }
        return *this;
    }
 
    virtual inline
    void setScaling(double scale, double offset){
        this->set(scale, offset); // virtual IMPORTANT for channels/view
    }
 
    virtual
    void setScaling(const ValueScaling & scaling){
        this->assignSequence(scaling);
    }
 
    virtual inline  // LATER: scalingPtr!
    const ValueScaling & getScaling() const {
        return *this;
    }
 
    virtual inline // LATER: scalingPtr!
    ValueScaling & getScaling(){
        return *this;
    }
 
 
 
    inline
    void setAbsoluteScale(){
        set(1.0, 0.0);
    }
 
 
    inline
    void setNormalScale(const std::type_info & t){
        if (Type::call<drain::typeIsSmallInt>(t))
            set(1.0/drain::Type::call<drain::typeMax,double>(t), 0.0);
        else  // warn? (esp. for int and long int)
            set(1.0, 0.0); // absolute scale
    }
 
    inline
    void setConversionScale(double scale, double offset = 0.0, double scaleOut=1.0, double offsetOut=0.0){
        set(scale/scaleOut, (offset - offsetOut)/scaleOut);
    }
 
    inline
    void setConversionScale(const drain::ValueScaling & s1, const drain::ValueScaling & s2){
        set(s2.scale/s1.scale, (s2.offset-s1.offset) / s1.scale);
    }
 
    //template <typename T>
    inline
    void setConversionScale(const Range<double> & r1, const Range<double> & r2){
        set(r2.width()/r1.width(), r2.min - r2.width()/r1.width()*r1.min);
    }
 
    void setOptimalScale(const std::type_info & t);
 
 
    inline
    void setPhysicalScale(const std::type_info & t, double min, double max){
        setPhysicalRange(min, max);
        setOptimalScale(t);
    }
 
 
    inline
    void setPhysicalScale(const std::type_info & t, const drain::ValueScaling & scaling){
        setPhysicalRange(scaling.getPhysicalRange());
        setOptimalScale(t);
    };
 
    inline
    const Range<double> & getPhysicalRange() const { // , const std::string &unit ?
        return physRange;
    }
 
    inline
    Range<double> & getPhysicalRange() { // , const std::string &unit ?
        return physRange;
    }
 
    inline
    void setPhysicalMax(double max){ // dangerous (after min?)
        setPhysicalRange(0.0, max);
    }
 
    template <class T>
    inline
    void setPhysicalRange(const Range<T> &range){ // , const std::string &unit ?
        physRange.assignSequence(range);
    }
 
    inline
    void setPhysicalRange(double min, double max){ // , const std::string &unit ?
        physRange.set(min,max);
    }
 
    inline
    double getScale() const { return scale; }
 
    inline
    double getOffset() const { return offset; }
 
 
    inline
    bool isScaled() const {
        return (scale!=1.0) || (offset!=0.0);
    }
 
    inline
    double getMinPhys() const {
        return physRange.min;
    }
 
    inline
    double getMaxPhys() const {
        return physRange.max;
    }
 
    inline
    bool isPhysical() const {
        return (!physRange.empty());
    }
 
    /*   short => float
     *
     */
    //inline
    void adoptScaling(const drain::ValueScaling & srcScaling, const std::type_info & srcType, const std::type_info & dstType = typeid(void));
 
 
    inline
    double fwd(double x) const {
        return scale*x + offset;
    }
 
    inline
    double inv(double y) const {
        return (y - offset) / scale;
    }
 
    virtual inline
    void toStream(std::ostream & ostr) const override {
        ostr << scale << ',' << offset;
        if (isPhysical())
             ostr << " [" << physRange << ']';
    }
 
    inline
    std::string str() const{
        std::stringstream sstr;
        toStream(sstr);
        return sstr.str();
    }
 
 
 
};
 
inline
std::ostream & operator<<(std::ostream &ostr, const drain::ValueScaling & s){
    s.toStream(ostr);
    return ostr;
}
 
} // drain::
 
#endif
 
// Drain