CDMInterpolator.h

Go to the documentation of this file.

/*
 * Fimex
 *
 * (C) Copyright 2008, met.no
 *
 * Project Info:  https://wiki.met.no/fimex/start
 *
 * This library 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.
 *
 * This library 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 this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
 * USA.
 */

#ifndef CDMINTERPOLATOR_H_
#define CDMINTERPOLATOR_H_

#include <vector>
#include <map>
#include "fimex/CDMReader.h"
#include "fimex/CachedInterpolation.h"
#include "fimex/CachedVectorReprojection.h"
#include "fimex/CrossSectionDefinition.h"
#include "fimex/deprecated.h"


namespace MetNoFimex
{
// forward decl
class CoordinateSystem;
struct CDMInterpolatorInternals;

class InterpolatorProcess2d {
public:
    virtual void operator()(float* array, size_t nx, size_t ny) = 0;
    virtual ~InterpolatorProcess2d() {};
};

class InterpolatorFill2d : public InterpolatorProcess2d {
private:
    float relaxCrit_;
    float corrEff_;
    size_t maxLoop_;
public:
    InterpolatorFill2d(float relaxCrit, float corrEff, size_t maxLoop)
        : relaxCrit_(relaxCrit), corrEff_(corrEff), maxLoop_(maxLoop) {}
    virtual void operator()(float* array, size_t nx, size_t ny) {size_t nChanged; mifi_fill2d_f(nx, ny, array, relaxCrit_, corrEff_, maxLoop_, &nChanged);};
};

class InterpolatorCreepFill2d : public InterpolatorProcess2d {
private:
    unsigned short repeat_;
    char setWeight_;
public:
    InterpolatorCreepFill2d(unsigned short repeat, char setWeight)
        : repeat_(repeat), setWeight_(setWeight) {}
    virtual void operator()(float* array, size_t nx, size_t ny) {size_t nChanged; mifi_creepfill2d_f(nx, ny, array, repeat_, setWeight_, &nChanged);};
};

class InterpolatorCreepFillVal2d : public InterpolatorProcess2d {
private:
    unsigned short repeat_;
    char setWeight_;
    float defVal_;
public:
    InterpolatorCreepFillVal2d(unsigned short repeat, char setWeight, float defaultValue)
        : repeat_(repeat), setWeight_(setWeight), defVal_(defaultValue) {}
    virtual void operator()(float* array, size_t nx, size_t ny) {size_t nChanged; mifi_creepfillval2d_f(nx, ny, array, defVal_, repeat_, setWeight_, &nChanged);};
};


class CDMInterpolator : public MetNoFimex::CDMReader
{
private:
    // the pimpl
    class boost::shared_ptr<CDMInterpolatorInternals> p_;
    void axisString2Vector(const std::string& axis, std::vector<double>& axis_vals, int axisId);
    void changeProjectionByProjectionParameters(int method, const std::string& proj_input, const std::vector<double>& out_x_axis, const std::vector<double>& out_y_axis, const std::string& out_x_axis_unit, const std::string& out_y_axis_unit, CDMDataType out_x_axis_type, CDMDataType out_y_axis_type);
    void changeProjectionByCoordinates(int method, const std::string& proj_input, const std::vector<double>& out_x_axis, const std::vector<double>& out_y_axis, const std::string& out_x_axis_unit, const std::string& out_y_axis_unit, CDMDataType out_x_axis_type, CDMDataType out_y_axis_type);
    void changeProjectionByForwardInterpolation(int method, const std::string& proj_input, const std::vector<double>& out_x_axis, const std::vector<double>& out_y_axis, const std::string& out_x_axis_unit, const std::string& out_y_axis_unit, CDMDataType out_x_axis_type, CDMDataType out_y_axis_type);

    void changeProjectionByProjectionParametersToLatLonTemplate(int method,
                                                                const std::string& proj_input,
                                                                const std::vector<double>& out_x_axis,
                                                                const std::vector<double>& out_y_axis,
                                                                const std::string& out_x_axis_unit,
                                                                const std::string& out_y_axis_unit,
                                                                CDMDataType out_x_axis_type,
                                                                CDMDataType out_y_axis_type,
                                                                DataPtr templateLatValues,
                                                                DataPtr templateLonValues);

    std::map<std::string, boost::shared_ptr<const CoordinateSystem> > findBestCoordinateSystemsAndProjectionVars(bool withProjection);
    bool hasXYSpatialVectors() const;
    bool allXYSpatialVectorsHaveSameHorizontalId(std::string horizontalId, std::string& exampleVar1, std::string& exampleVar2) const;
public:
    CDMInterpolator(boost::shared_ptr<CDMReader> dataReader);
    virtual ~CDMInterpolator();
    using CDMReader::getDataSlice;
    virtual DataPtr getDataSlice(const std::string& varName, size_t unLimDimPos = 0);
    virtual DataPtr getDataSlice(const std::string& varName, const SliceBuilder& sb);

    virtual void changeProjection(int method, const std::string& proj_input, const std::vector<double>& out_x_axis, const std::vector<double>& out_y_axis, const std::string& out_x_axis_unit, const std::string& out_y_axis_unit, CDMDataType out_x_axis_type, CDMDataType out_y_axis_type);
    MIFI_DEPRECATED(virtual void changeProjection(int method, const std::string& proj_input, const std::vector<double>& out_x_axis, const std::vector<double>& out_y_axis, const std::string& out_x_axis_unit, const std::string& out_y_axis_unit));
    virtual void changeProjection(int method, const std::string& proj_input, const std::string& out_x_axis, const std::string& out_y_axis, const std::string& out_x_axis_unit, const std::string& out_y_axis_unit, const std::string& out_x_axis_type = "double", const std::string& out_y_axis_type = "double");
    virtual void changeProjection(int method, const std::string& netcdf_template_file);
    virtual void changeProjection(int method, const std::vector<double>& lonVals, const std::vector<double>& latVals);
    virtual void changeProjectionToCrossSections(int method, const std::vector<CrossSectionDefinition>& crossSections);
    virtual void setLatitudeName(const std::string& latName);
    virtual const std::string& getLatitudeName() const;
    virtual void setLongitudeName(const std::string& lonName);
    virtual const std::string& getLongitudeName() const;
    virtual double getMaxDistanceOfInterest(const std::vector<double>& out_y_axis, const std::vector<double>& out_x_axis, bool isMetric) const;
    virtual void setDistanceOfInterest(double dist);
    virtual void addPreprocess(boost::shared_ptr<InterpolatorProcess2d> process);
    virtual void addPostprocess(boost::shared_ptr<InterpolatorProcess2d> process);
};

extern boost::shared_array<float> data2InterpolationArray(const DataPtr& inData, double badValue);

extern DataPtr interpolationArray2Data(CDMDataType newType, boost::shared_array<float> iData, size_t size, double badValue);


}

#endif /*CDMINTERPOLATOR_H_*/