indexed_array.hpp

Go to the documentation of this file.

/*

PICCANTE
The hottest HDR imaging library!
http://vcg.isti.cnr.it/piccante

Copyright (C) 2014
Visual Computing Laboratory - ISTI CNR
http://vcg.isti.cnr.it
First author: Francesco Banterle

This Source Code Form is subject to the terms of the Mozilla Public
License, v. 2.0. If a copy of the MPL was not distributed with this
file, You can obtain one at http://mozilla.org/MPL/2.0/.

*/

#ifndef PIC_UTIL_INDEXED_ARRAY_HPP
#define PIC_UTIL_INDEXED_ARRAY_HPP

#include <vector>

#include "../util/math.hpp"

namespace pic {

typedef std::vector<int> IntCoord;

template <class T>
class IndexedArray
{
public:
    IndexedArray()
    {
    }

    static bool bFuncNotNeg(T val)
    {
        return val > T(0);
    }

    static bool bFuncNotZero(T val)
    {
        return (val < T(0)) || (val > T(0));
    }

    static bool bFuncNeg(T val)
    {
        return (val < T(0));
    }

    static void findSimple(T *data, int nData, bool(*func)(float), IntCoord &ret, int stride = 1)
    {
        for(int i = 0; i < nData; i += stride) {
            if(func(data[i])) {
                ret.push_back(i);
            }
        }
    }

    static void find(float *data, int nData, bool(*func)(float,
                     std::vector<float>), std::vector<float> param, IntCoord &ret)
    {
        for(int i = 0; i < nData; i++) {
            if(func(data[i], param)) {
                ret.push_back(i);
            }
        }
    }

    static T mean(T *data, IntCoord &coord)
    {
        if(coord.empty()) {
            return T(0);
        }

        T ret = data[coord[0]];

        for(unsigned int i = 1; i < coord.size(); i++) {
            int j = coord[i];
            ret += data[j];
        }

        ret /= T(coord.size());

        return ret;
    }

    static T min(T *data, IntCoord &coord)
    {
        if(coord.empty()) {
            return T(0);
        }

        float ret = data[coord[0]];

        for(unsigned int i = 1; i < coord.size(); i++) {
            int j = coord[i];
            ret = MIN(ret, data[j]);
        }

        return ret;
    }

    static T max(T *data, IntCoord &coord)
    {
        if(coord.empty()) {
            return T(0);
        }

        T ret = data[coord[0]];

        for(unsigned int i = 1; i < coord.size(); i++) {
            int j = coord[i];
            ret = MAX(ret, data[j]);
        }

        return ret;
    }

    static T percentile(T *data, IntCoord &coord, float percent)
    {
        if(coord.empty()) {
            return T(0);
        }

        int n = int(coord.size());
        T *tmp = new T[n];

        for(int i = 0; i < n; i++) {
            int j = coord[i];
            tmp[i] = data[j];
        }

        std::sort(tmp, tmp + n);

        percent = CLAMPi(percent, 0.0f, 1.0f);

        T ret = tmp[int(float(n - 1) * percent)];
        delete[] tmp;

        return ret;
    }

    static void scale(IntCoord &coord, int scale)
    {
        for(unsigned int i = 0; i < coord.size(); i++) {
            coord.at(i) = coord.at(i) * scale;
        }
    }

    static float log10Mean(float *data, IntCoord &coord)
    {
        if(coord.empty()) {
            return FLT_MAX;
        }

        float delta = 1e-6f;
        float ret = 0.0f;

        for(unsigned int i = 0; i < coord.size(); i++) {
            int j = coord[i];
            ret += log10f(data[j] + delta);
        }

        return ret / float(coord.size());
    }

    static float log2Mean(float *data, IntCoord &coord)
    {
        if(coord.empty()) {
            return FLT_MAX;
        }

        float delta = 1e-6f;
        float ret = 0.0f;
        float log2f = logf(2.0f);

        for(unsigned int i = 0; i < coord.size(); i++) {
            int j = coord[i];
            ret += logf(data[j] + delta) / log2f;
        }

        return ret / float(coord.size());
    }

    static void negative(T *data, IntCoord &coord, T referencePoint = T(1))
    {
        for(unsigned int i = 0; i < coord.size(); i++) {
            int j = coord[i];
            data[j] = referencePoint - data[j];
        }
    }

    static void add(T *data, IntCoord &coord, T val)
    {
        for(unsigned int i = 0; i < coord.size(); i++) {
            int j = coord[i];
            data[j] += val;
        }
    }

    static void sub(T *data, IntCoord &coord, T val)
    {
        for(unsigned int i = 0; i < coord.size(); i++) {
            int j = coord[i];
            data[j] -= val;
        }
    }

    static void mul(T *data, IntCoord &coord, T val)
    {
        for(unsigned int i = 0; i < coord.size(); i++) {
            int j = coord[i];
            data[j] *= val;
        }
    }

    static void div(T *dataDst, IntCoord &coord, T val)
    {
        for(unsigned int i = 0; i < coord.size(); i++) {
            int j = coord[i];
            dataDst[j] /= val;
        }
    }

    static void assign(T *dataDst, IntCoord &coord, T dataSrc)
    {
        for(unsigned int i = 0; i < coord.size(); i++) {
            int j = coord[i];
            dataDst[j] = dataSrc;
        }
    }

    static void assign(T *dataDst, IntCoord &coord, T *dataSrc)
    {
        for(unsigned int i = 0; i < coord.size(); i++) {
            int j = coord[i];
            dataDst[j] = dataSrc[j];
        }
    }
};

typedef IndexedArray<float> IndexedArrayf;

typedef IndexedArray<int> IndexedArrayi;

typedef IndexedArray<unsigned int> IndexedArrayui;

} // end namespace pic

#endif /* PIC_UTIL_INDEXED_ARRAY_HPP */