utils.h

Go to the documentation of this file.

#ifndef DFACE_UTILS_H
#define DFACE_UTILS_H

#include <stdio.h>
#include <string>
#include <iostream>
#include <sstream>
#include <fstream>
#include <vector>
#include <math.h>


union FloatType {
    float FloatNum;
    int IntNum;
};


typedef union {
    int i;
    char c;
}my_union;


static int checkSystem(void)
{
    my_union u;
    u.i = 1;
    return (u.i == u.c);
}


static void convertBytes2Feature(unsigned char* bytes, int length, std::vector<float> &feature) {
    int feathreLen = length / 4;
    for (int i = 0; i<feathreLen; i++) {
        FloatType Number;
        Number.IntNum = 0;
        Number.IntNum = bytes[4 * i + 3];
        Number.IntNum = (Number.IntNum << 8) | bytes[4 * i + 2];
        Number.IntNum = (Number.IntNum << 8) | bytes[4 * i + 1];
        Number.IntNum = (Number.IntNum << 8) | bytes[4 * i + 0];
        feature.push_back(Number.FloatNum);
    }
}


static unsigned char* convertFeature2Bytes(std::vector<float> &feature, int &length){
    if (feature.size() == 0) {
        length = 0;
        return NULL;
    }
    length = 4 * feature.size();
    unsigned char * DataBuf = new unsigned char[length];
    for (int i = 0; i < feature.size(); i++) {
        FloatType Number;
        Number.FloatNum = feature[i];
        DataBuf[4 * i + 0] = (unsigned char)Number.IntNum;
        DataBuf[4 * i + 1] = (unsigned char)(Number.IntNum >> 8);
        DataBuf[4 * i + 2] = (unsigned char)(Number.IntNum >> 16);
        DataBuf[4 * i + 3] = (unsigned char)(Number.IntNum >> 24);
    }
    return DataBuf;
}


static inline void convertFeature2Str(std::vector<float> &feature, std::string& str) {
    if (feature.size() == 0) {
        return;
    }
    std::stringstream stmstr;
    for (int i = 0; i< feature.size(); i++) {
        stmstr << feature[i] << ',';
    }
    std::string restr = stmstr.str();
    str = restr.substr(0, restr.length() - 1);
}


static inline std::vector<std::string> explodeStr(const std::string &s, const char &c) {
    std::string buff;
    std::vector<std::string> v;
    char tmp;
    for (int i = 0; i<s.size(); i++)
    {
        tmp = s[i];
        if (tmp != c) {
            buff += tmp;
        }
        else {
            if (tmp == c && buff != "") {
                v.push_back(buff);
                buff = "";
            }
        }//endif
    }
    if (buff != "")
    {
        v.push_back(buff);
    }
    return v;
}


static inline void convertStr2Feature(std::string& str, std::vector<float> &feature){
    std::vector<std::string> fstrs = explodeStr(str, ',');
    if (fstrs.size() == 0) {
        return;
    }
    for (int i = 0; i<fstrs.size(); i++) {
        float f = atof(fstrs[i].c_str());
        feature.push_back(f);
    }
}

//vector norm
static inline float norm(const std::vector<float>& vec){
    int n = vec.size();
    float sum = 0.0;
    for (int i = 0; i<n; ++i)
        sum += vec[i] * vec[i];
    return sqrt(sum);
}


static inline float similarityByFeature(std::vector<unsigned char>& feature1, std::vector<unsigned char>& feature2){
    std::vector<float> feature_arr1;
    std::vector<float> feature_arr2;
    convertBytes2Feature(feature1.data(), feature1.size(), feature_arr1);
    convertBytes2Feature(feature2.data(), feature2.size(), feature_arr2);

    int n = feature_arr1.size();
    float tmp = 0.0;
    for (int i = 0; i<n; ++i){
        tmp += feature_arr1[i] * feature_arr2[i];
    }
    float cosine = tmp / (norm(feature_arr1)*norm(feature_arr2));
    float norm_cosine = 0.5 + 0.5 * cosine;
    return norm_cosine;
}



static inline std::string getPathName(const std::string& s) {
    char sep = '/';
#ifdef _WIN32
    sep = '\\';
#endif
    size_t i = s.rfind(sep, s.length());
    if (i != std::string::npos) {
        return(s.substr(0, i));
    }
    return("");
}


static inline std::vector<std::string> split_str(const std::string& str, const std::string& delim)
{
    std::vector<std::string> tokens;
    size_t prev = 0, pos = 0;
    do
    {
        pos = str.find(delim, prev);
        if (pos == std::string::npos) pos = str.length();
        std::string token = str.substr(prev, pos-prev);
        if (!token.empty()) tokens.push_back(token);
        prev = pos + delim.length();
    }
    while (pos < str.length() && prev < str.length());
    return tokens;
}

static inline void replace_str(std::string& str, const std::string& before, const std::string& after)
{
    for (std::string::size_type pos(0); pos != std::string::npos; pos += after.length())
    {
        pos = str.find(before, pos);
        if (pos != std::string::npos)
            str.replace(pos, before.length(), after);
        else
            break;
    }
}


#endif //DFACE_UTILS_H