Utility.hpp

Go to the documentation of this file.

#pragma once
#include "FAST/ExecutionDevice.hpp"
#include "FAST/Data/DataTypes.hpp"
#include <algorithm>
#include <functional>
#include <cctype>
#include <locale>
 
// This file contains a set of utility functions
 
// Undefine windows crap
#undef min
#undef max
 
namespace fast {
 
FAST_EXPORT double log2(double n);
FAST_EXPORT double round(double n);
FAST_EXPORT double round(double n, int decimals);
 
template <class T>
T square(T x) {
    return x*x;
}
 
template <typename ...Args>
std::string format(std::string format, Args && ... args) {
    auto size = std::snprintf(nullptr, 0, format.c_str(), std::forward<Args>(args)...);
    std::string output(size + 1, '\0');
    std::sprintf(&output[0], format.c_str(), std::forward<Args>(args)...);
    return output;
}
 
template<class T>
T min(T a, T b) {
    return a < b ? a : b;
}
 
template<class T>
T max(T a, T b) {
    return a > b ? a : b;
}
 
template<class T>
T sign(T value) {
    if(value > 0) {
        return 1;
    } else if (value < 0) {
        return -1;
    } else {
        return 0;
    }
}
 
FAST_EXPORT unsigned int getPowerOfTwoSize(unsigned int size);
FAST_EXPORT void* allocateDataArray(unsigned int voxels, DataType type, unsigned int nrOfComponents);
template <class T>
float getSumFromOpenCLImageResult(void* voidData, unsigned int size, unsigned int nrOfComponents) {
    T* data = (T*)voidData;
    float sum = 0.0f;
    for(unsigned int i = 0; i < size*nrOfComponents; i += nrOfComponents) {
        sum += data[i];
    }
    return sum;
}
 
FAST_EXPORT void getMaxAndMinFromOpenCLImage(OpenCLDevice::pointer device, cl::Image2D image, DataType type, float* min, float* max);
FAST_EXPORT void getMaxAndMinFromOpenCLImage(OpenCLDevice::pointer device, cl::Image3D image, DataType type, float* min, float* max);
FAST_EXPORT void getMaxAndMinFromOpenCLBuffer(OpenCLDevice::pointer device, cl::Buffer buffer, unsigned int size, DataType type, float* min, float* max);
FAST_EXPORT void getIntensitySumFromOpenCLImage(OpenCLDevice::pointer device, cl::Image2D image, DataType type, float* sum);
 
template <class T>
void getMaxAndMinFromData(void* voidData, unsigned int nrOfElements, float* min, float* max) {
    T* data = (T*)voidData;
 
    *min = std::numeric_limits<float>::max();
    *max = std::numeric_limits<float>::min();
    for(unsigned int i = 0; i < nrOfElements; i++) {
        if((float)data[i] < *min) {
            *min = (float)data[i];
        }
        if((float)data[i] > *max) {
            *max = (float)data[i];
        }
    }
}
 
template <class T>
float getSumFromData(void* voidData, unsigned int nrOfElements) {
    T* data = (T*)voidData;
 
    float sum = 0.0f;
    for(unsigned int i = 0; i < nrOfElements; i++) {
        sum += (float)data[i];
    }
    return sum;
}
 
FAST_EXPORT cl::size_t<3> createRegion(unsigned int x, unsigned int y, unsigned int z);
FAST_EXPORT cl::size_t<3> createRegion(Vector3ui size);
FAST_EXPORT cl::size_t<3> createOrigoRegion();
 
FAST_EXPORT std::string getCLErrorString(cl_int err);
 
FAST_EXPORT std::vector<std::string> split(const std::string input, const std::string& delimiter = " ", float removeEmpty = true);
 
// trim from start (in place)
static inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(),
        [](unsigned char c) {return !std::isspace(c); }));
}
 
// trim from end (in place)
static inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(),
        [](unsigned char c) {return !std::isspace(c); }).base(), s.end());
}
 
// trim from both ends (in place)
static inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
}
 
/*
 * Replace all occurences of from to to in str
 */
FAST_EXPORT std::string replace(std::string str, std::string find, std::string replacement);
 
template <class T>
static inline void hash_combine(std::size_t& seed, const T& v)
{
    std::hash<T> hasher;
    seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);
}
 
FAST_EXPORT Matrix4f loadPerspectiveMatrix(float fovy, float aspect, float zNear, float zFar);
 
FAST_EXPORT Matrix4f loadOrthographicMatrix(float left, float right, float bottom, float top, float zNear, float zFar);
 
FAST_EXPORT void createDirectory(std::string path);
 
FAST_EXPORT void createDirectories(std::string path);
 
FAST_EXPORT bool fileExists(std::string filename);
 
FAST_EXPORT std::vector<std::string> getDirectoryList(std::string path, bool getFiles = true, bool getDirectories = false);
 
FAST_EXPORT std::string getDirName(std::string path);
 
FAST_EXPORT std::string currentDateTime(std::string format = "%Y-%m-%d-%H%M%S");
 
FAST_EXPORT std::string join(std::string path);
 
FAST_EXPORT std::string getModifiedDate(std::string filename);
 
template<typename ...T>
std::string join(const std::string& path1, T... args) {
    return path1 + "/" + join(args...);
}
 
FAST_EXPORT bool isFile(const std::string& path);
 
FAST_EXPORT bool isDir(const std::string& path);
 
template <class T>
std::unique_ptr<T> make_uninitialized_unique(std::size_t size) {
    return std::unique_ptr<T>(new typename std::remove_extent<T>::type[size]);
}
 
FAST_EXPORT void extractZipFile(std::string zipFilepath, std::string destination);
 
FAST_EXPORT std::string stringToLower(std::string);
FAST_EXPORT std::string stringToUpper(std::string);
 
} // end namespace fast