Utils.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 UTILS_H_
#define UTILS_H_

#include <vector>
#include <utility>
#include <iterator>
#include <sstream>
#include <cmath>
#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <boost/math/special_functions/fpclassify.hpp>
#include <boost/regex.hpp>
#include <limits>
#include "fimex/CDMException.h"
#include "fimex/UnitsConverter.h"
#include <boost/shared_array.hpp>

namespace MetNoFimex
{
int round(double num);

std::string trim(const std::string& str);

template<class InputIterator>
std::string join(InputIterator start, InputIterator end, std::string delim = ",")
{
    if (start == end) return "";
    std::ostringstream buffer;
    InputIterator current = start++;
    while (start != end) {
        buffer << *current << delim;
        current = start++;
    }
    buffer << *current;
    return buffer.str();
}

template<typename InputIterator>
std::pair<typename std::iterator_traits<InputIterator>::difference_type, typename std::iterator_traits<InputIterator>::difference_type>
find_closest_distinct_elements(InputIterator start, InputIterator end, double x)
{
    using namespace std;
    typename iterator_traits<InputIterator>::difference_type retVal1 = 0;
    typename iterator_traits<InputIterator>::difference_type retVal2 = 0;
    InputIterator cur = start;
    typename iterator_traits<InputIterator>::value_type v1;
    double v1Diff, v2Diff;
    if (start != end) {
        v1 = *start;
        v1Diff = abs(x-*start);
        v2Diff = v1Diff;
    }
    while (cur != end) {
        double vDiff = fabs(x-*cur);
        if (vDiff <= v2Diff) {
            if (vDiff < v1Diff) {
                retVal2 = retVal1;
                v2Diff = v1Diff;
                v1 = *cur;
                retVal1 = distance(start, cur);
                v1Diff = vDiff;
            } else if (*cur != v1) {
                retVal2 = distance(start, cur);
                v2Diff = vDiff;
            }
        } // else nothing to be done
        cur++;
    }
    return make_pair<typename iterator_traits<InputIterator>::difference_type, typename iterator_traits<InputIterator>::difference_type>(retVal1, retVal2);
}

template<typename InputIterator>
std::pair<typename std::iterator_traits<InputIterator>::difference_type, typename std::iterator_traits<InputIterator>::difference_type>
find_closest_neighbor_distinct_elements(InputIterator start, InputIterator end, double x)
{
    using namespace std;
    if (start == end)
        return make_pair<typename iterator_traits<InputIterator>::difference_type, typename iterator_traits<InputIterator>::difference_type>(0, 0);

    InputIterator lowest = start;
    InputIterator heighest = start;
    InputIterator cur = start;
    double lowDiff = x - *cur;
    double heighDiff = *cur -x;
    double maxDiff = std::numeric_limits<double>::max();
    if (lowDiff < 0)
        lowDiff = maxDiff;
    if (heighDiff < 0)
        heighDiff = maxDiff;
    while (++cur != end) {
        if (*cur <= x) {
            double diff = x - *cur;
            if (diff < lowDiff) {
                lowDiff = diff;
                lowest = cur;
            }
        } else {
            double diff = *cur - x;
            if (diff < heighDiff) {
                heighDiff = diff;
                heighest = cur;
            }
        }
    }
    if (lowDiff == maxDiff ||
            heighDiff == maxDiff) {
        // extrapolating
        return find_closest_distinct_elements(start, end, x);
    }

    return make_pair<typename iterator_traits<InputIterator>::difference_type, typename iterator_traits<InputIterator>::difference_type>(distance(start, lowest), distance(start, heighest));

}
template<class InputIterator>
std::string joinPtr(InputIterator start, InputIterator end, std::string delim = ",")
{
    if (start == end) return "";
    std::ostringstream buffer;
    InputIterator current = start++;
    while (start != end) {
        buffer << **current << delim;
        current = start++;
    }
    buffer << **current;
    return buffer.str();
}

std::vector<std::string> tokenize(const std::string& str, const std::string& delimiters = " ");


std::string string2lowerCase(const std::string& str);

template<typename T>
std::string type2string(T in) {
    std::ostringstream buffer;
    buffer << in;
    return buffer.str();
}

template<>
std::string type2string<double>(double in);


template<typename T>
T string2type(std::string s) {
    T retVal;
    std::stringstream buffer;
    buffer << s;
    buffer >> retVal;
    return retVal;
}

template<typename T>
struct Varargs {
    std::vector<T> args;
    Varargs& operator()(T arg) {args.push_back(arg); return *this;}
    Varargs(T arg) {args.push_back(arg);}
};


template<typename T>
T normalizeLongitude180(T in) {
    while (in < -180) {
        in += 360;
    }
    while (in > 180) {
        in -= 360;
    }
    return in;
}



typedef long epoch_seconds;
epoch_seconds posixTime2epochTime(const boost::posix_time::ptime& time);

template<typename T>
std::vector<T> tokenizeDotted(const std::string& str, const std::string& delimiter = ",") throw(CDMException)
{
    std::vector<std::string> tokens = tokenize(str, delimiter);
    std::vector<T> vals;
    for (std::vector<std::string>::iterator tok = tokens.begin(); tok != tokens.end(); ++tok) {
        std::string current = trim(*tok);
        if (current == "...") {
            size_t currentPos = vals.size();
            if (currentPos < 2) {
                throw CDMException("tokenizeDotted: cannot use ... expansion at position " + type2string(currentPos-1) +", need at least two values before");
            }
            T last = vals[currentPos-1];
            T dist = last - vals[currentPos-2];
            T curVal = last + dist;
            // positive if values get larger, negative if curVal gets samller
            double direction = (dist > 0) ? 1 : -1;
            if (++tok != tokens.end()) {
                T afterDotVal = string2type<T>(*tok);
                // expand the dots until before the afterDotVal, compare against rounding error
                double roundError = direction*dist*-1.e-5;
                while ((curVal - afterDotVal)*direction < roundError) {
                    vals.push_back(curVal);
                    curVal += dist;
                }
                // add the afterDotVal
                vals.push_back(afterDotVal);
            }
        } else {
            T val = string2type<T>(current);
            vals.push_back(val);
        }
    }
    return vals;
}

template<typename OUT>
struct staticCast {
    template<typename IN>
    OUT operator()(const IN& in) { return static_cast<OUT>(in); }
};

template<typename C>
int mifi_isnan(C x) {
    return boost::math::isnan(x);
}

void scanFiles(std::vector<std::string>& files, const std::string& dir, int depth, const boost::regex& regexp, bool matchFileOnly);
void globFiles(std::vector<std::string>& files, const std::string& glob);

template<typename IN, typename OUT>
class ScaleValue : public std::unary_function<IN, OUT>
{
private:
    IN oldFill_;
    double oldScaleNewScaleInv_;
    double oldOffsetMinusNewOffsetNewScaleInv_;
    OUT newFill_;
public:
    ScaleValue(double oldFill, double oldScale, double oldOffset, double newFill, double newScale, double newOffset) :
        oldFill_(static_cast<IN>(oldFill)), oldScaleNewScaleInv_(oldScale/newScale),
        oldOffsetMinusNewOffsetNewScaleInv_((oldOffset-newOffset)/newScale),
        newFill_(static_cast<OUT>(newFill)) {}
    OUT operator()(const IN& in) const {
        return (in == oldFill_ || mifi_isnan<IN>(in))
            ? newFill_
            : static_cast<OUT>(oldScaleNewScaleInv_*in + oldOffsetMinusNewOffsetNewScaleInv_);
            //(((oldScale_*in + oldOffset_)-newOffset_)/newScale_);
            // => ((oldScale_*in + oldOffsetMinusNewOffset_)*newScaleInv_);
            // => oldScaleNewScale_ * in + oldOffsetMinusNewOffsetNewScale_
    }
};

template<typename IN, typename OUT>
class ScaleValueUnits : public std::unary_function<IN, OUT>
{
private:
    IN oldFill_;
    double oldScale_;
    double oldOffset_;
    boost::shared_ptr<UnitsConverter> uconv_;
    OUT newFill_;
    double newScaleInv_;
    double newOffset_;
public:
    ScaleValueUnits(double oldFill, double oldScale, double oldOffset, boost::shared_ptr<UnitsConverter> uconv, double newFill, double newScale, double newOffset) :
        oldFill_(static_cast<IN>(oldFill)), oldScale_(oldScale), oldOffset_(oldOffset),
        uconv_(uconv),
        newFill_(static_cast<OUT>(newFill)), newScaleInv_(1/newScale), newOffset_(newOffset) {}
    OUT operator()(const IN& in) const {
        return (in == oldFill_ || mifi_isnan<IN>(in))
                ? newFill_
                : static_cast<OUT>((uconv_->convert(oldScale_*in + oldOffset_)-newOffset_)*newScaleInv_);
    }
};


template<typename IN, typename OUT>
class ChangeMissingValue : public std::unary_function<IN, OUT>
{
private:
    IN oldFill_;
    OUT newFill_;
public:
    ChangeMissingValue(double oldFill, double newFill) :
        oldFill_(static_cast<IN>(oldFill)), newFill_(static_cast<OUT>(newFill)) {}
    OUT operator()(const IN& in) const {
        return (in == oldFill_ || mifi_isnan(in))
                ? newFill_
                : static_cast<OUT>(in);
    }
};

template<typename T>
struct SharedArrayConstCastDeleter {
    SharedArrayConstCastDeleter( boost::shared_array<T> ptr ) : ptr(ptr) {};
    template<typename C> void operator()(C*) {}
protected:
    boost::shared_array<T> ptr;
};
template<typename T>
boost::shared_array<const T> makeSharedArrayConst(const boost::shared_array<T>& sa) {
    return boost::shared_array<const T>(sa.get(), SharedArrayConstCastDeleter<T>(sa));
}


}

#endif /*UTILS_H_*/