DopplerInversionWindow.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 DOPPLER_Inversion_WINDOW_H_
#define DOPPLER_Inversion_WINDOW_H_
 
 
//#include "DopplerWindowOp.h"
 
#include <cmath>
 
#include "RadarWindows.h"
 
namespace rack {
 
 
 
class DopplerInversionConfig : public RadarWindowConfig {
public:
 
    inline
    DopplerInversionConfig(int widthM=1500, double heightD=3.0) :
        RadarWindowConfig(widthM, heightD){
    };
 
};
 
class DopplerInversionMoments {
public:
 
};
 
class DopplerInversionWindow : public SlidingRadarWindow<DopplerInversionConfig> {
    //drain::image::SlidingWindowT<> { // TODO: move to Analysis.h, Templatize => SlidingWindowT
 
 
public:
 
    DopplerInversionWindow(const DopplerInversionConfig & conf, const PolarODIM & odimOut) :
        SlidingRadarWindow<DopplerInversionConfig>(conf) , odimOut(odimOut), functor(NULL)
        //, dSpan(3), dSpan2(2.0*dSpan)
        { };
 
    inline
    void setDstFrame2(drain::image::Image &d2){
        dst2.setView(d2);
    }
 
 
    // Unneeded!? (Unchanged)
    /*
    inline
    void setImageLimits() const {
        src.adjustCoordinateHandler(coordinateHandler);
    }
    */
 
 
    virtual
    void initialize();
 
    inline
    bool getDerivative(const drain::Point2D<int> &p, double & diff, bool debug=false) const {
 
        drain::Point2D<int> pTmp;
 
        pTmp.setLocation(p.x, p.y - 1);
        if (!this->coordinateHandler.validate(pTmp))
            return false;
        const double d1 = src.get<double>(pTmp);
 
        pTmp.setLocation(p.x, p.y + 1);
        if (!this->coordinateHandler.validate(pTmp))
            return false;
        const double d2 = src.get<double>(pTmp);
 
        if (odimSrc.deriveDifference(d1, d2, diff)){
            diff *= 0.5; // due to above +1/-1
            /*
            if (debug && isDiag(2)){
                std::cerr << " {" << d1 << ',' << d2 << "} \t => (" << odimSrc.scaleForward(d1) << ',' << odimSrc.scaleForward(d2) << "}\t => " << diff << '\n';
            }
            */
            return true;
        }
        else
            return false;
 
    }
 
 
    const PolarODIM & odimOut;
 
    std::string functorSetup; // TODO: use that of Window::
 
 
protected:
 
    drain::UnaryFunctor *functor; // pointer :-(   TODO: use that of Window::
 
    drain::FuzzyBell2<double> diffQuality;
    drain::FuzzyBell2<double> matrixInformation;
 
    virtual inline
    void addLeadingValue(double x){};
 
    virtual inline
    void removeTrailingValue(double x){};
 
    //inline    bool retrieveSpeedSample(d1, d2)
 
 
    virtual
    void addPixel(drain::Point2D<int> &p);
 
    virtual
    void removePixel(drain::Point2D<int> &p);
 
    virtual
    void write();
 
protected:
 
    drain::image::ImageView dst2;
 
    virtual
    void clear();
 
    inline
    bool isDiag(int step) const {
        return (location.x == location.y) && (location.x % step == 0);
    }
 
 
private:
 
    double u = 0.0;
    double v = 0.0;
 
    mutable double vMax;
 
    // Matrix determinant
    double div;
 
    // Output quality
    double quality;
 
    // Used for computing derivatives in addPixel/removePixel
    drain::Point2D<int> locationTmp;
 
    //mutable double NI;
 
    // mutable double NI2;
 
 
    //const int    dSpan;
    //const double dSpan2;
 
 
    double diff;
 
 
 
 
    //  sum of differences
    double sumDiff;
    //  sum differences Squared
    double sumDiff2;
 
    // count/weight (quality weight)
    double w;
    // area, const (max weight)
    double area;
 
    double sTd;
 
    double cTd;
 
    double sTs;
 
    double cTc;
 
    double cTs;
 
 
    // Experimental
    double sV;
    double cV;
 
 
 
 
    // Speed differences
    double d1,d2;
 
    double s,c;
 
    //drain::FuzzyStepsoid<double> qualityFunctor;
    drain::FuzzyBell<double> qualityFunctor;
 
};
 
 
class DopplerInversionWindowWeighted : public DopplerInversionWindow {
 
 
public:
 
    DopplerInversionWindowWeighted(const DopplerInversionConfig & conf, const PolarODIM & odimOut) :
        DopplerInversionWindow(conf, odimOut)   {
    };
 
};
 
 
}  // ::rack
 
 
#endif /* DOPPLERInversionOP_H_ */