RadarProductOp.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)
*/
/*
 * ProductOp.h
 *
 *  Created on: Mar 7, 2011
 *      Author: mpeura
 */
 
#ifndef RACK_PRODUCT_OP
#define RACK_PRODUCT_OP "ProductOP"
 
//#include <exception>
#include <drain/Log.h>
#include <iostream>
#include <list>
#include <map>
#include <set>
#include <string>
 
#include <drain/RegExp.h>
#include <drain/util/SmartMap.h>
#include <drain/util/TreeOrdered.h>
 
#include "data/Data.h"
#include "data/DataSelector.h"
#include "data/ODIM.h"
#include "data/ODIMPath.h"
#include "data/ODIMPathTools.h"
#include "data/QuantityMap.h"
 
#include "hi5/Hi5.h"
//#include "main/rack.h"
 
 
 
#include "ProductBase.h"
 
namespace rack {
 
using namespace drain::image;
 
 
 
template <class MS, class MD>
class RadarProductOp : public ProductBase {
 
public:
 
    typedef SrcType<MS const> src_t;
 
    typedef DstType<MD> dst_t;
 
 
    inline
    RadarProductOp(const std::string &name, const std::string & description) : ProductBase(name, description) {
        // dataSelector.path = "^.* / da ta[0-9]+/?$";  /// Contract: in Op's, path filters should be copy to group level.
    }
 
    inline
    RadarProductOp(const RadarProductOp & product) : ProductBase(product){
        std::cerr << '#' << __FUNCTION__ << " copy ct " << product.getName() << this->dataSelector << '\n';
    };
 
    MD odim;
 
    /*
    virtual inline
    const std::string & getOutputQuantity() const {
        return odim.quantity; //outputQuantity;
    }
    */
 
 
    virtual inline
    const std::string & getOutputQuantity(const std::string & inputQuantity = "") const {
        if (!odim.quantity.empty())
            return odim.quantity; //outputQuantity;
        else
            return inputQuantity;
    }
 
 
    //void processH5() // see MotionFill
    virtual // HistogramOp
    void processH5(const Hi5Tree &src, Hi5Tree &dst) const;
 
 
 
    virtual
    void computeSingleProduct(const DataSetMap<src_t> & srcSweeps, DataSet<dst_t> & dstProduct) const;
 
 
    virtual
    void processDataSet(const DataSet<src_t > & srcSweep, DataSet<DstType<MD> > & dstProduct) const;
 
    virtual
    void processData(const Data<src_t > & srcData, Data<dst_t > & dstData) const {
        drain::Logger mout(__FILE__, __FUNCTION__);
        mout.unimplemented(__FUNCTION__);
    };
 
 
protected:
 
 
 
    virtual
    void setGeometry(const MS & srcODIM, PlainData<dst_t > & dstData) const = 0; // {};
 
 
 
    virtual inline
    void initDst(const MS & srcODIM, PlainData<dst_t > & dstData) const {
 
        drain::Logger mout(__FILE__, __FUNCTION__); //REPL this->name+"(VolumeOp<M>)", __FUNCTION__);
 
        setEncoding(srcODIM, dstData);
        setGeometry(srcODIM, dstData);
 
        mout.debug("final dstData: " , dstData );
    }
 
 
 
    //virtual
    //void setEncodingNEW(PlainData<dst_t > & dstData) const;
 
 
    virtual
    void setEncoding(const ODIM & srcODIM, PlainData<dst_t > & dstData) const;
 
 
    // void ProductOp<MS,MD>::setEncodingNEW
    void setEncodingNEW(PlainData<dst_t> & dstData, const std::string & quantity = "", const std::string & args = "") const;
 
    /*
    static
    void handleEncodingRequest(const std::string & encoding, PlainData<dst_t> & dst){
 
        drain::Logger mout(__FILE__, __FUNCTION__);
 
        dst.odim.completeEncoding( encoding);
 
        if (!dst.odim.type.empty())
            dst.data.setType(dst.odim.type);
        else
            dst.odim.type = (const char)dst.data.getType2();
 
    }
    */
};
 
template <class MS, class MD>
void RadarProductOp<MS,MD>::setEncodingNEW(PlainData<dst_t> & dstData,  const std::string & quantity, const std::string & args) const {
 
    drain::Logger mout(__FILE__, __FUNCTION__);
 
    if (dstData.odim.quantity.empty()){
        dstData.odim.quantity = quantity;
    }
 
    /*
    if (!type.empty()){
        dstData.odim.type = type;
    }
    */
 
    const std::string & qty = quantity.empty() ? dstData.odim.quantity : quantity;
 
    if (qty.empty()){
        mout.warn("No quantity in metadata or as argument" );
    }
 
    const QuantityMap & qmap = getQuantityMap();
 
    qmap.setQuantityDefaults(dstData, qty, args);
 
    /*
    qmap.setQuantityDefaults(dstData, qty, dstData.odim.type, );
    dstData.odim.updateValues(targetEncoding);
 
    // Why two times?
    qmap.setQuantityDefaults(dstData, qty, dstData.odim.type); // type also?
    dstData.odim.updateValues(targetEncoding);
    */
 
    // update
    dstData.data.setScaling(odim.scaling);
 
    // dstData.odim.product = odim.product; ?
}
 
/*
template <class MS, class MD>
void ProductOp<MS,MD>::setEncodingNEW(PlainData<dst_t> & dst, const std::string quantity = "", const std::string type = "") const {
 
    drain::Logger mout(__FILE__, __FUNCTION__);
 
    if (odim.quantity.empty())
        odim.quantity = quantity;
 
    if (!type.empty())
        odim.type = type;
 
    const std::string & qty = quantity.empty() ? odim.quantity : quantity;
 
    const QuantityMap & qmap = getQuantityMap();
    qmap.setQuantityDefaults(dst, qty, odim.type);
    dst.odim.updateValues(targetEncoding);
    qmap.setQuantityDefaults(dst, qty, dst.odim.type); // type also?
    dst.odim.updateValues(targetEncoding);
    // update
    dst.data.setScaling(dst.odim.scaling);
 
    // dst.odim.product = odim.product; ?
}
*/
 
/*
 *   This is one of the many parallel similar implementations. To be removed.
 *   See also:
 */
template <class MS, class MD>
void RadarProductOp<MS,MD>::setEncoding(const ODIM & inputODIM, PlainData<dst_t> & dst) const {
 
    ProductBase::applyODIM(dst.odim, this->odim);
    ProductBase::applyODIM(dst.odim, inputODIM, true);  // New. Use defaults if still unset
    dst.odim.completeEncoding( this->targetEncoding);
 
    drain::Logger mout(__FILE__, __FUNCTION__);
 
    //mout.unimplemented<LOG_WARNING>("Does not set data storage type?");
 
    // Set actual scaling up to date with metadata)
    dst.data.setScaling(dst.odim.scaling);
    // dst.odim.product = odim.product;
}
 
 
template <class MS, class MD>  // copied from VolumeOp::processVolume
void RadarProductOp<MS,MD>::processH5(const Hi5Tree &src, Hi5Tree &dst) const {
 
    //drain::Logger mout(__FILE__, __FUNCTION__); //REPL this->name+"(VolumeOp<M>)", __FUNCTION__);
    drain::Logger mout(__FILE__, __FUNCTION__);
 
    mout.debug("start");
    mout.note(getName(), ':', *this);
    mout.debug2("DataSelector: ", this->dataSelector);
 
    // Step 1: collect sweeps (/datasetN/)
    //DataSetMap<src_t> sweeps;
    DataSetMap<src_t> sweeps;
 
    mout.debug3("collect the applicable paths");
    ODIMPathList dataPaths;  // Down to ../dataN/ level, eg. /dataset5/data4
    int index = 0;
 
 
    // mout.unimplemented<LOG_DEBUG>("No index generator defined!");
 
 
    // NEW
    this->dataSelector.getPaths(src, dataPaths); //, ODIMPathElem::DATASET);
    mout.debug3("populate the dataset map, paths=" , dataPaths.size() );
    //for (ODIMPathList::const_iterator it = dataPaths.begin(); it != dataPaths.end(); ++it){
    for (const ODIMPath & path: dataPaths){
        //mout.debug3("add: " , index , '\t' , path  );
        mout.experimental("adding: " , index , '\t' , path);
        //sweeps.insert(typename DataSetMap<src_t>::value_type("indexxx", DataSet<src_t>(src(path), drain::RegExp(this->dataSelector.getQuantity()) )));  // Something like: sweeps[elangle] = src[parent] .
        sweeps.insert(typename DataSetMap<src_t>::value_type("indexxx", DataSet<src_t>(src(path), this->dataSelector.getQuantitySelector() )));  // Something like: sweeps[elangle] = src[parent] .
    }
 
 
    // OLD
    /*
    this->dataSelector.getPaths(src, dataPaths, ODIMPathElem::DATA);
 
    mout.debug3("populate the dataset map, paths=" , dataPaths.size() );
    std::set<ODIMPath> parents;
 
    for (ODIMPathList::const_iterator it = dataPaths.begin(); it != dataPaths.end(); ++it){
 
        ODIMPath parent = *it;
        parent.pop_back();
 
        mout.debug3("check "  , *it );
 
        if (parents.find(parent) == parents.end()){
            mout.debug3("add " , parent  , "=>" , index );
            // kludge (index ~ elevation)
            sweeps.insert(typename DataSetMap<src_t>::value_type(index, DataSet<src_t>(src(parent), drain::RegExp(this->dataSelector.quantity) )));  // Something like: sweeps[elangle] = src[parent] .
            //elangles << elangle;
        }
    }
    */
 
 
    mout.debug2("DataSets: "  , sweeps.size() );
 
 
    // Copy metadata from the input volume (note that dst may have been cleared above)
    for (const auto & key: {ODIMPathElem::WHAT, ODIMPathElem::WHERE, ODIMPathElem::HOW}){
        // .data.attributes
        mout.note("Copying: ", key);
        mout.unimplemented("consider and test .data.attributes instead");
        dst[key] = src[key];
    }
    // odim.copyToRoot(dst); NO! Mainly overwrites original data. fgrep 'declare(rootAttribute' odim/*.cpp
 
    //ODIMPath dataSetPath;
    ODIMPathElem parent(ODIMPathElem::DATASET); // /dataset1
    ODIMPathElem child(ODIMPathElem::DATA); // /dataset1
 
    mout.note(DRAIN_LOG(ProductBase::appendResults));
    if (ProductBase::appendResults.getType() == ODIMPathElem::DATASET){
        ODIMPathTools::getNextChild(dst, parent);
    }
 
    ODIMPathTools::getNextChild(dst[parent], child);
 
    mout.attention("storing product in path: " ,  parent , '|' , child );
    Hi5Tree & dstProduct = dst[parent][child]; // (dataSetPath);
 
    {
        DataSet<dst_t> dstProductDataset(dstProduct); // PATH
        this->computeSingleProduct(sweeps, dstProductDataset);
    }
 
    dst["what"].data.attributes["object"] = this->odim.object;
    dstProduct["what"].data.attributes["product"] = odim.product;
    dstProduct["what"].data.attributes["prodpar"] = odim.prodpar;
 
    ProductBase::setRackVersion(dstProduct["how"].data.attributes);
    // how["elangles"] = elangles;  // This service could be lower in hierarchy (but for PseudoRHI and pCappi ok here)
 
}
 
 
//template <class M>
template <class MS, class MD>
void RadarProductOp<MS,MD>::computeSingleProduct(const DataSetMap<src_t > & src, DataSet<DstType<MD> > & dstProduct) const {
 
    drain::Logger mout(__FILE__, __FUNCTION__); //REPL this->name+"(VolumeOp<M>)", __FUNCTION__);
    mout.debug3("start" );
 
    if (src.size() == 0)
        mout.warn("no data" );
 
    //for (typename DataSetMap<src_t >::const_iterator it = src.begin(); it != src.end(); ++it) {
    for (const auto & entry: src) {
        mout.debug3("calling processDataSet for elev=", entry.first,  " #datasets=", entry.second.size());
        processDataSet(entry.second, dstProduct);
        // TODO: detect first init?
        // mout.warn("OK" );
    }
 
    // mout.warn("getFirst data" );
    //@ Data<DstType<MD> > & dstData = dstProduct.getFirstData(); // main data
    //@ dstProduct.updateTree(dstData.odim);
    // mout.warn("end" );
}
 
 
//template <class M>
template <class MS, class MD>
void RadarProductOp<MS,MD>::processDataSet(const DataSet<src_t > & srcSweep, DataSet<DstType<MD> > & dstProduct) const {
 
    //drain::Logger mout(__FILE__, __FUNCTION__); //REPL this->name+"(ProductOp<MS,MD>)", __FUNCTION__);
    drain::Logger mout(__FILE__, __FUNCTION__);
 
    mout.debug("start" );
 
    const Data<src_t > & srcData = srcSweep.getFirstData();
 
    mout.debug("target quantity: " , odim.quantity );
 
    // NEW 2020/06
    const std::string & quantity = !odim.quantity.empty() ? odim.quantity : srcData.odim.quantity;
    Data<DstType<MD> > & dstData =  dstProduct.getData(quantity);
    dstData.odim.quantity = quantity;
 
    // OLD
    // Data<DstType<MD> > & dstData = !odim.quantity.empty() ? dstProduct.getData(odim.quantity) : dstProduct.getFirstData();
    //if (dstData.odim.quantity.empty())
    //  dstData.odim.quantity = odim.quantity;
 
    //mout.debug("calling setEncoding" );
    //setEncoding(srcData.odim, dstData.odim);
    this->initDst(srcData.odim, dstData);
 
    //mout.warn("calling processData" );
    processData(srcData, dstData);
    //mout.warn("updateTree" );
    //@ dstData.updateTree();
}
 
 
 
 
 
}  // namespace rack
 
 
#endif /* RACKOP_H_ */
 
// Rack
 // REP
 // REP // REP // REP // REP