822 lines
24 KiB
C++
822 lines
24 KiB
C++
#include "myutils.h"
|
||
|
||
namespace ai_matrix
|
||
{
|
||
const int TIME_DIFF = 28800; // 8 hour
|
||
MyUtils *MyUtils::ins = nullptr;
|
||
MyUtils::GarbageCollector MyUtils::gc;
|
||
std::mutex MyUtils::mx;
|
||
|
||
MyUtils *MyUtils::getins()
|
||
{
|
||
//双层锁，确保线程安全
|
||
if (ins == nullptr)
|
||
{
|
||
std::lock_guard<std::mutex> guard(mx); //防止异常发生不能解锁
|
||
if (ins == nullptr)
|
||
{
|
||
ins = new MyUtils();
|
||
}
|
||
}
|
||
return ins;
|
||
}
|
||
|
||
float MyUtils::getMean(const std::vector<float> &data)
|
||
{
|
||
int size = data.size();
|
||
|
||
if (size == 0)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
float sum = 0;
|
||
for (int i = 0; i < size; i++)
|
||
{
|
||
sum += data[i];
|
||
}
|
||
return sum / size;
|
||
}
|
||
|
||
float MyUtils::getMax(const std::vector<float> &data)
|
||
{
|
||
int size = data.size();
|
||
|
||
if (size == 0)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
float max = 0;
|
||
for (int i = 0; i < size; i++)
|
||
{
|
||
if (i == 0)
|
||
{
|
||
max = data[i];
|
||
}
|
||
else if (data[i] > max)
|
||
{
|
||
max = data[i];
|
||
}
|
||
}
|
||
return max;
|
||
}
|
||
|
||
float MyUtils::getMin(const std::vector<float> &data)
|
||
{
|
||
int size = data.size();
|
||
|
||
if (size == 0)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
float min = 0;
|
||
for (int i = 0; i < size; i++)
|
||
{
|
||
if (i == 0)
|
||
{
|
||
min = data[i];
|
||
}
|
||
else if (data[i] < min)
|
||
{
|
||
min = data[i];
|
||
}
|
||
}
|
||
return min;
|
||
}
|
||
|
||
float MyUtils::getMedian(const std::vector<float> &data)
|
||
{
|
||
if (data.size() < 2)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
std::vector<float> data_tmp;
|
||
|
||
int n = data.size();
|
||
for (int i = 0; i < n; i++)
|
||
{
|
||
data_tmp.push_back(data[i]);
|
||
}
|
||
|
||
std::sort(data_tmp.begin(), data_tmp.end(), std::less<float>());
|
||
|
||
if (n % 2 == 0)
|
||
{
|
||
return (data_tmp[n / 2] + data_tmp[n / 2 - 1]) / 2;
|
||
}
|
||
else
|
||
{
|
||
return data_tmp[(n - 1) / 2];
|
||
}
|
||
}
|
||
|
||
std::string MyUtils::get_timestamp_file()
|
||
{
|
||
time_t timep = time(NULL);
|
||
struct tm *p = localtime(&timep);
|
||
|
||
struct timeval tv;
|
||
gettimeofday(&tv, NULL);
|
||
|
||
int msec = tv.tv_usec / 1000;
|
||
|
||
char tmp[30] = {0};
|
||
sprintf(tmp, "%04d-%02d-%02d-%02d-%02d-%02d-%03d", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec, msec);
|
||
|
||
return std::string(tmp);
|
||
}
|
||
|
||
std::string MyUtils::get_date()
|
||
{
|
||
time_t timep = time(NULL);
|
||
struct tm *p = localtime(&timep);
|
||
|
||
struct timeval tv;
|
||
gettimeofday(&tv, NULL);
|
||
|
||
int msec = tv.tv_usec / 1000;
|
||
|
||
char tmp[12] = { 0 };
|
||
sprintf(tmp, "%04d-%02d-%02d", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday);
|
||
|
||
return std::string(tmp);
|
||
}
|
||
|
||
std::string MyUtils::get_time()
|
||
{
|
||
time_t timep = time(NULL);
|
||
struct tm *p = localtime(&timep);
|
||
|
||
struct timeval tv;
|
||
gettimeofday(&tv, NULL);
|
||
|
||
int msec = tv.tv_usec / 1000;
|
||
|
||
char tmp[10] = { 0 };
|
||
sprintf(tmp, "%02d-%02d-%02d", p->tm_hour, p->tm_min, p->tm_sec);
|
||
|
||
return std::string(tmp);
|
||
}
|
||
|
||
std::string MyUtils::get_timestamp_log()
|
||
{
|
||
time_t timep = time(NULL);
|
||
struct tm *p = localtime(&timep);
|
||
|
||
struct timeval tv;
|
||
gettimeofday(&tv, NULL);
|
||
|
||
int msec = tv.tv_usec / 1000;
|
||
|
||
char tmp[30] = {0};
|
||
sprintf(tmp, "%04d-%02d-%02d %02d:%02d:%02d.%03d", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec, msec);
|
||
|
||
return std::string(tmp);
|
||
}
|
||
|
||
std::string MyUtils::create_dir_name(std::string root, std::string name)
|
||
{
|
||
std::string dir_path = root + "/" + name;
|
||
if (access(dir_path.c_str(), F_OK) != 0)
|
||
{
|
||
if (mkdir(dir_path.c_str(), 0755) != 0) //如果父目录不存在，会创建失败
|
||
{
|
||
perror("mkdir fail");
|
||
return "";
|
||
}
|
||
}
|
||
return dir_path;
|
||
}
|
||
|
||
std::string MyUtils::create_dir_date(std::string root)
|
||
{
|
||
time_t timep = time(NULL);
|
||
struct tm *p = localtime(&timep);
|
||
|
||
char tmp_date[20] = {0};
|
||
sprintf(tmp_date, "%04d-%02d-%02d", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday);
|
||
|
||
std::string dir_path;
|
||
|
||
dir_path = root + "/" + std::string(tmp_date); //创建日期目录
|
||
if (access(dir_path.c_str(), F_OK) != 0)
|
||
{
|
||
if (mkdir(dir_path.c_str(), 0755) != 0) //如果父目录不存在，会创建失败
|
||
{
|
||
perror("mkdir fail");
|
||
return "";
|
||
}
|
||
}
|
||
|
||
return dir_path;
|
||
}
|
||
|
||
std::string MyUtils::create_dir_date_name_time(std::string root, std::string name)
|
||
{
|
||
time_t timep = time(NULL);
|
||
struct tm *p = localtime(&timep);
|
||
|
||
char tmp_date[20] = {0};
|
||
sprintf(tmp_date, "%04d-%02d-%02d", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday);
|
||
|
||
char tmp_time[20] = {0};
|
||
sprintf(tmp_time, "%02d-%02d-%02d", p->tm_hour, p->tm_min, p->tm_sec);
|
||
|
||
std::string dir_path;
|
||
|
||
dir_path = root + "/" + std::string(tmp_date); //创建日期目录
|
||
if (access(dir_path.c_str(), F_OK) != 0)
|
||
{
|
||
if (mkdir(dir_path.c_str(), 0755) != 0) //如果父目录不存在，会创建失败
|
||
{
|
||
perror("mkdir fail");
|
||
return "";
|
||
}
|
||
}
|
||
|
||
dir_path = dir_path + "/" + name + "_" + std::string(tmp_time); //创建点云目录
|
||
if (access(dir_path.c_str(), F_OK) != 0)
|
||
{
|
||
if (mkdir(dir_path.c_str(), 0755) != 0) //如果父目录不存在，会创建失败
|
||
{
|
||
perror("mkdir fail");
|
||
return "";
|
||
}
|
||
}
|
||
|
||
return dir_path;
|
||
}
|
||
|
||
std::string MyUtils::create_file_path(std::string root, std::string name, std::string suffix)
|
||
{
|
||
time_t timep = time(NULL);
|
||
struct tm *p = localtime(&timep);
|
||
|
||
char tmp_date[20] = {0};
|
||
sprintf(tmp_date, "%04d-%02d-%02d", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday);
|
||
|
||
char tmp_time[20] = {0};
|
||
sprintf(tmp_time, "%02d-%02d-%02d", p->tm_hour, p->tm_min, p->tm_sec);
|
||
|
||
std::string file_path;
|
||
|
||
file_path = root + "/" + std::string(tmp_date); //创建日期目录
|
||
if (access(file_path.c_str(), F_OK) != 0)
|
||
{
|
||
if (mkdir(file_path.c_str(), 0755) != 0) //如果父目录不存在，会创建失败
|
||
{
|
||
perror("mkdir fail");
|
||
return "";
|
||
}
|
||
}
|
||
|
||
file_path = file_path + "/" + name + "_" + std::string(tmp_time) + suffix; //创建文件
|
||
|
||
return file_path;
|
||
}
|
||
|
||
//字符串分割函数
|
||
std::vector<std::string> MyUtils::split(std::string str, std::string pattern)
|
||
{
|
||
std::string::size_type pos;
|
||
std::vector<std::string> result;
|
||
str += pattern; //扩展字符串以方便操作
|
||
int size = str.size();
|
||
for (int i = 0; i < size; i++)
|
||
{
|
||
pos = str.find(pattern, i);
|
||
if (pos < size)
|
||
{
|
||
std::string s = str.substr(i, pos - i);
|
||
result.push_back(s);
|
||
i = pos + pattern.size() - 1;
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
std::string MyUtils::getStringFromFloat(float f)
|
||
{
|
||
std::ostringstream buffer;
|
||
buffer << f;
|
||
return buffer.str();
|
||
}
|
||
std::string MyUtils::getStringFromBool(bool b)
|
||
{
|
||
std::ostringstream buffer;
|
||
buffer << b;
|
||
return buffer.str();
|
||
}
|
||
|
||
/**
|
||
* 拷贝文件
|
||
* @param filePath 源文件位置
|
||
* @param savePath 将要拷贝的新位置
|
||
* @return
|
||
*/
|
||
bool MyUtils::copyFile(std::string filePath, std::string savePath)
|
||
{
|
||
FILE *fp, *sp;
|
||
fp = fopen(filePath.c_str(), "rb");
|
||
sp = fopen(savePath.c_str(), "w+b");
|
||
if (!fp || !sp)
|
||
{
|
||
LogError << "open fial filePath:" << filePath << " or savePath:" << savePath;
|
||
return false;
|
||
}
|
||
void *buffer;
|
||
while (!feof(fp))
|
||
{
|
||
fread(&buffer, 1, 1, fp);
|
||
fwrite(&buffer, 1, 1, sp);
|
||
}
|
||
fclose(fp);
|
||
fclose(sp);
|
||
return true;
|
||
}
|
||
|
||
std::string& MyUtils::replace_all_distinct(std::string &str, const std::string &old_value, const std::string &new_value)
|
||
{
|
||
for (std::string::size_type pos(0); pos != std::string::npos; pos += new_value.length()) {
|
||
if ((pos = str.find(old_value, pos)) != std::string::npos)
|
||
str.replace(pos, old_value.length(), new_value);
|
||
else break;
|
||
}
|
||
return str;
|
||
}
|
||
|
||
/**
|
||
* 获取北京当前日期
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : 日期
|
||
*/
|
||
std::string MyUtils::GetDate()
|
||
{
|
||
struct timeval time = {0, 0};
|
||
gettimeofday(&time, nullptr);
|
||
time_t timep = time.tv_sec + TIME_DIFF;
|
||
|
||
struct tm *p = gmtime(&timep);
|
||
|
||
char szTmp[12] = {0};
|
||
sprintf(szTmp, "%04d-%02d-%02d", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday);
|
||
|
||
return std::string(szTmp);
|
||
}
|
||
|
||
/**
|
||
* 获取北京当前时间
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : 时间
|
||
*/
|
||
std::string MyUtils::GetTime()
|
||
{
|
||
struct timeval time = {0, 0};
|
||
gettimeofday(&time, nullptr);
|
||
time_t timep = time.tv_sec + TIME_DIFF;
|
||
|
||
struct tm *p = gmtime(&timep);
|
||
|
||
char szTmp[10] = {0};
|
||
sprintf(szTmp, "%02d-%02d-%02d", p->tm_hour, p->tm_min, p->tm_sec);
|
||
return std::string(szTmp);
|
||
}
|
||
|
||
//时间戳转化为时间 毫秒级
|
||
std::string MyUtils::Stamp2Time(long long timestamp, bool has_msec)
|
||
{
|
||
int ms = timestamp % 1000;//取毫秒
|
||
time_t tick = (time_t)(timestamp/1000);//转换时间
|
||
struct tm tm;
|
||
char s[40];
|
||
tm = *localtime(&tick);
|
||
strftime(s, sizeof(s), "%Y-%m-%d %H:%M:%S", &tm);
|
||
std::string str(s);
|
||
if (has_msec)
|
||
{
|
||
str = str+ "." + std::to_string(ms);
|
||
}
|
||
return str;
|
||
}
|
||
|
||
/**
|
||
* 获取当前时间距1970年的毫秒数
|
||
* inParam : N/A
|
||
* outParam: N/A
|
||
* return : 时间戳
|
||
*/
|
||
uint64_t MyUtils::GetCurrentTimeMillis()
|
||
{
|
||
struct timeval tv;
|
||
gettimeofday(&tv, NULL);
|
||
//printf("tv_sec:%ld, tv_usec:%ld\n", tv.tv_sec, tv.tv_usec);
|
||
return tv.tv_sec * 1000 + tv.tv_usec / 1000;
|
||
}
|
||
|
||
/**
|
||
* 获取指定时间距1970年的毫秒数 (入参格式：YYYY-MM-DD hh-mm-ss)
|
||
* inParam : std::string &strDateTime 日期时间
|
||
* outParam: N/A
|
||
* return : 时间戳
|
||
*/
|
||
uint64_t MyUtils::GetParamTimeMilliSeconds(std::string &strDateTime)
|
||
{
|
||
LogDebug << "strDateTime:" << strDateTime;
|
||
if (strDateTime.length() != 19)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int iYear = atoi(strDateTime.substr(0, 4).c_str());
|
||
int iMon = atoi(strDateTime.substr(5, 2).c_str());
|
||
int iDay = atoi(strDateTime.substr(8, 2).c_str());
|
||
int iHour = atoi(strDateTime.substr(11, 2).c_str());
|
||
int iMin = atoi(strDateTime.substr(14, 2).c_str());
|
||
int iSec = atoi(strDateTime.substr(17, 2).c_str());
|
||
|
||
struct tm stm;
|
||
memset(&stm, 0, sizeof(stm));
|
||
stm.tm_year = iYear - 1900;
|
||
stm.tm_mon = iMon - 1;
|
||
stm.tm_mday = iDay;
|
||
stm.tm_hour = iHour;
|
||
stm.tm_min = iMin;
|
||
stm.tm_sec = iSec;
|
||
|
||
uint64_t i64Ret = (uint64_t)mktime(&stm) * 1000;
|
||
LogDebug << iYear << " " << iMon << " " << iDay << " " << iHour << " " << iMin << " " << iSec << " " << i64Ret;
|
||
return i64Ret;
|
||
}
|
||
|
||
/**
|
||
* Anchor行分割
|
||
* inParam : std::string &strLine Anchor一行内容
|
||
* : const std::set<char> &setDelimiters 分割符集合
|
||
* outParam: N/A
|
||
* return : 分割数据
|
||
*/
|
||
std::vector<float> MyUtils::SplitAnchor(std::string &strLine, const std::set<char> &setDelimiters)
|
||
{
|
||
std::vector<float> result;
|
||
if (strLine.empty())
|
||
{
|
||
return result;
|
||
}
|
||
char const *pch = strLine.c_str();
|
||
char const *start = pch;
|
||
for (; *pch; ++pch)
|
||
{
|
||
if (setDelimiters.find(*pch) != setDelimiters.end())
|
||
{
|
||
if (start != pch)
|
||
{
|
||
std::string tmp(start, pch);
|
||
result.push_back(atof(tmp.c_str())); //浮点数
|
||
}
|
||
start = pch + 1;
|
||
}
|
||
}
|
||
result.push_back(atof(start)); //最后一个内容
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 创建文件夹路径
|
||
* inParam : std::string strDirPath :文件夹路径
|
||
* outParam: N/A
|
||
* return : true/false
|
||
*/
|
||
bool MyUtils::CreateDirPath(std::string strDirPath)
|
||
{
|
||
if (strDirPath.back() != '/')
|
||
{
|
||
strDirPath += "/";
|
||
}
|
||
|
||
if (access(strDirPath.c_str(), F_OK) == 0)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
std::string::size_type pos = strDirPath.find('/');
|
||
while (pos != std::string::npos)
|
||
{
|
||
std::string strCur = strDirPath.substr(0, pos);
|
||
if (!strCur.empty() && access(strCur.c_str(), F_OK) != 0)
|
||
{
|
||
if (mkdir(strCur.c_str(), 0755) != 0) //如果父目录不存在，会创建失败
|
||
{
|
||
perror("mkdir fail");
|
||
return false;
|
||
}
|
||
|
||
if (chmod(strCur.c_str(), 0777) != 0)
|
||
{
|
||
perror("chmod fail");
|
||
}
|
||
}
|
||
pos = strDirPath.find('/', pos + 1);
|
||
}
|
||
return true;
|
||
}
|
||
|
||
#ifdef ASCEND
|
||
/**
|
||
* 拷贝Device数据到Host
|
||
* inParam : void *pDeviceBuffer device内存地址
|
||
: uint32_t iBufferSize device内存大小
|
||
* outParam: std::shared_ptr<void> *pHostData host内存地址 (size同入参)
|
||
* return : N/A
|
||
*/
|
||
bool MyUtils::MemcpyDeviceToHost(std::shared_ptr<void> *pHostData, const void *pDeviceBuffer, uint32_t iBufferSize)
|
||
{
|
||
if (pDeviceBuffer == nullptr || iBufferSize == 0)
|
||
{
|
||
LogError << "MemcpyDeviceToHost fail pDeviceBuffer is null or iBufferSize is 0";
|
||
return false;
|
||
}
|
||
|
||
void *pHostBuffer = nullptr;
|
||
int iRet = aclrtMallocHost(&pHostBuffer, iBufferSize);
|
||
if (iRet != APP_ERR_OK)
|
||
{
|
||
LogError << "MemcpyDeviceToHost aclrtMallocHost fail, iBufferSize:" << iBufferSize << " iRet:" << iRet;
|
||
return false;
|
||
}
|
||
|
||
pHostData->reset(pHostBuffer, aclrtFreeHost);
|
||
|
||
iRet = aclrtMemcpy(pHostData->get(), iBufferSize, pDeviceBuffer, iBufferSize, ACL_MEMCPY_DEVICE_TO_HOST);
|
||
if (iRet != APP_ERR_OK)
|
||
{
|
||
LogError << "MemcpyDeviceToHost aclrtMemcpy fail, iBufferSize:" << iBufferSize << " iRet:" << iRet;
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 拷贝Host数据到Device
|
||
* inParam : void *pHostBuffer host内存地址
|
||
: uint32_t iBufferSize host内存大小
|
||
: bool bDvppFlag 是否使用dvpp方式申请device内存(默认true)
|
||
* outParam: std::shared_ptr<void> *pDeviceData device内存地址 (size同入参)
|
||
* return : N/A
|
||
*/
|
||
bool MyUtils::MemcpyHostToDevice(std::shared_ptr<void> *pDeviceData, const void *pHostBuffer, uint32_t iBufferSize, bool bDvppFlag/*=true*/)
|
||
{
|
||
if (pHostBuffer == nullptr || iBufferSize == 0)
|
||
{
|
||
LogError << "MemcpyHostToDevice fail pHostBuffer is null or iBufferSize is 0";
|
||
return false;
|
||
}
|
||
|
||
int iRet = APP_ERR_OK;
|
||
void *pDeviceBuffer = nullptr;
|
||
if (bDvppFlag)
|
||
{
|
||
int iRet = acldvppMalloc(&pDeviceBuffer, iBufferSize);
|
||
if (iRet != APP_ERR_OK)
|
||
{
|
||
LogError << "MemcpyHostToDevice acldvppMalloc fail, iBufferSize:" << iBufferSize << " iRet:" << iRet;
|
||
return false;
|
||
}
|
||
pDeviceData->reset(pDeviceBuffer, acldvppFree);
|
||
}
|
||
else
|
||
{
|
||
int iRet = aclrtMalloc(&pDeviceBuffer, iBufferSize, ACL_MEM_MALLOC_HUGE_FIRST);
|
||
if (iRet != APP_ERR_OK)
|
||
{
|
||
LogError << "MemcpyHostToDevice aclrtMalloc fail, iBufferSize:" << iBufferSize << " iRet:" << iRet;
|
||
return false;
|
||
}
|
||
pDeviceData->reset(pDeviceBuffer, aclrtFree);
|
||
}
|
||
|
||
iRet = aclrtMemcpy(pDeviceData->get(), iBufferSize, pHostBuffer, iBufferSize, ACL_MEMCPY_HOST_TO_DEVICE);
|
||
if (iRet != APP_ERR_OK)
|
||
{
|
||
LogError << "MemcpyHostToDevice aclrtMemcpy fail, iBufferSize:" << iBufferSize << " iRet:" << iRet;
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
#endif
|
||
|
||
/**
|
||
* 获取指定毫秒数的对应的北京日期时间
|
||
* inParam : uint64_t i64MilliSeconds
|
||
* outParam: N/A
|
||
* return : 日期时间
|
||
*/
|
||
std::string MyUtils::GetDateTimeByMilliSeconds(uint64_t i64MilliSeconds, bool bFormatFlag/*=false*/)
|
||
{
|
||
time_t timep = i64MilliSeconds / 1000 + TIME_DIFF;
|
||
struct tm *p = gmtime(&timep);
|
||
|
||
char szTmp[32] = {0};
|
||
if (bFormatFlag)
|
||
{
|
||
sprintf(szTmp, "%04d-%02d-%02d %02d:%02d:%02d", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec);
|
||
}
|
||
else
|
||
{
|
||
sprintf(szTmp, "%04d-%02d-%02d %02d-%02d-%02d", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec);
|
||
}
|
||
return std::string(szTmp);
|
||
}
|
||
|
||
/**
|
||
* 校验是否识别该目标
|
||
* inParam : std::string &strOneTarget
|
||
* outParam: N/A
|
||
* return : true/false
|
||
*/
|
||
bool MyUtils::ChkIsHaveTarget(const std::string &strOneTarget)
|
||
{
|
||
std::map<int, ai_matrix::DataSourceConfig> mapUseDataSouceCfg = MyYaml::GetIns()->GetUseDataSourceConfig();
|
||
bool bFindTarget = false;
|
||
for (auto iter = mapUseDataSouceCfg.begin(); iter != mapUseDataSouceCfg.end(); iter++)
|
||
{
|
||
if (iter->second.strTarget.find(strOneTarget) != std::string::npos)
|
||
{
|
||
bFindTarget = true;
|
||
break;
|
||
}
|
||
}
|
||
return bFindTarget;
|
||
}
|
||
|
||
/**
|
||
* 读取json格式文件内容
|
||
* inParam : std::string &strFilePath :文件路径
|
||
* outParam: Json::Value &jvFileInfo :json格式内容
|
||
* return : true/false
|
||
*/
|
||
bool MyUtils::ReadJsonInfo(Json::Value &jvFileInfo, std::string &strFilePath, int iRetry /*=3*/)
|
||
{
|
||
std::ifstream ifs(strFilePath.c_str());
|
||
int i = 0;
|
||
while (!ifs.is_open() && i < iRetry)
|
||
{
|
||
i++;
|
||
usleep(10 * 1000);
|
||
ifs.open(strFilePath.c_str());
|
||
}
|
||
if (!ifs.is_open())
|
||
{
|
||
// LogWarn << "txt:" << strFilePath << " open fail";
|
||
return false;
|
||
}
|
||
|
||
std::string strContent;
|
||
getline(ifs, strContent);
|
||
ifs.close();
|
||
|
||
Json::CharReaderBuilder jsrBuilder;
|
||
std::shared_ptr<Json::CharReader> reader(jsrBuilder.newCharReader());
|
||
JSONCPP_STRING errs;
|
||
if (!reader->parse(strContent.data(), strContent.data() + strContent.size(), &jvFileInfo, &errs))
|
||
{
|
||
LogWarn << "json parse fail content:" << strContent;
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* json格式内容写入文件
|
||
* inParam : Json::Value &jvFileInfo :json格式内容
|
||
: std::string &strFilePath :文件路径
|
||
* outParam: N/A
|
||
* return : true/false
|
||
*/
|
||
bool MyUtils::WriteJsonInfo(Json::Value &jvFileInfo, std::string &strFilePath)
|
||
{
|
||
Json::StreamWriterBuilder jswBuilder;
|
||
jswBuilder["indentation"] = "";
|
||
std::string strFrameInfo = Json::writeString(jswBuilder, jvFileInfo);
|
||
|
||
std::ofstream ofs(strFilePath.c_str());
|
||
if (!ofs.is_open())
|
||
{
|
||
LogWarn << "txt:" << strFilePath << " open fail";
|
||
return false;
|
||
}
|
||
ofs.write(strFrameInfo.c_str(), strFrameInfo.length());
|
||
ofs.close();
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 获取第1步得分最高框
|
||
* inParam : std::vector<stDetection> &vecResult 推理符合结果
|
||
* outParam: std::vector<stDetection> &vecResult 每个类别得分最高结果
|
||
* return : N/A
|
||
*/
|
||
void MyUtils::GetMaxScoreResult(std::vector<stDetection> &vecResult)
|
||
{
|
||
if (vecResult.size() < 2)
|
||
{
|
||
return;
|
||
}
|
||
std::map<Target, std::vector<stDetection>> mapResult;
|
||
for (size_t i = 0; i < vecResult.size(); i++)
|
||
{
|
||
stDetection stDTemp = vecResult.at(i);
|
||
if (stDTemp.class_id == 0)
|
||
{
|
||
mapResult[HEAD].emplace_back(stDTemp);
|
||
}
|
||
else if (stDTemp.class_id == 1)
|
||
{
|
||
mapResult[PRO].emplace_back(stDTemp);
|
||
}
|
||
else if ((stDTemp.class_id >= 2 && stDTemp.class_id <= 6) || stDTemp.class_id == 8 || stDTemp.class_id == 15)
|
||
{
|
||
mapResult[NUM].emplace_back(stDTemp);
|
||
}
|
||
else if (stDTemp.class_id >= 9 && stDTemp.class_id <= 17 && stDTemp.class_id != 15)
|
||
{
|
||
mapResult[TRAINSPACE].emplace_back(stDTemp);
|
||
}
|
||
else if (stDTemp.class_id == 18)
|
||
{
|
||
mapResult[SPACE].emplace_back(stDTemp);
|
||
}
|
||
}
|
||
|
||
//清空之前的结果
|
||
vecResult.clear();
|
||
// 每个类别中，获取得分最高的框
|
||
for (auto iter = mapResult.begin(); iter != mapResult.end(); iter++)
|
||
{
|
||
int iMaxPos = -1;
|
||
for (size_t i = 0; i < iter->second.size(); i++)
|
||
{
|
||
if (iMaxPos == -1)
|
||
{
|
||
iMaxPos = i;
|
||
}
|
||
else if (iter->second.at(i).class_conf > iter->second.at(iMaxPos).class_conf)
|
||
{
|
||
iMaxPos = i;
|
||
}
|
||
}
|
||
|
||
if (iMaxPos >= 0)
|
||
{
|
||
vecResult.emplace_back(iter->second.at(iMaxPos));
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取第二步缩放比例
|
||
* inParam : Step1Location &step1Location 第一步大框
|
||
: int iModelWidth 模型宽
|
||
: int iModelHeight 模型高
|
||
* outParam: N/A
|
||
* return : 缩放比例
|
||
*/
|
||
float MyUtils::GetStep2ResizeRatio(Step1Location &step1Location, int iModelWidth, int iModelHeight)
|
||
{
|
||
uint32_t iCropgWidth = step1Location.fRBX - step1Location.fLTX;
|
||
uint32_t iCropHeight = step1Location.fRBY - step1Location.fLTY;
|
||
float fRatioW = static_cast<float>(iCropgWidth) / iModelWidth;
|
||
float fRatioH = static_cast<float>(iCropHeight) / iModelHeight;
|
||
return (fRatioW > fRatioH) ? fRatioW : fRatioH;
|
||
}
|
||
|
||
/**
|
||
* 第二步坐标还原
|
||
* inParam : SingleData &singleData
|
||
: float fResizeRatio 比例
|
||
: std::shared_ptr<ProcessData> pProcessData 待处理数据
|
||
: Step1Location &step1Location 第一步大框在原图坐标
|
||
* outParam: SingleData &singleData
|
||
* return : N/A
|
||
*/
|
||
void MyUtils::Step2ResetLocation(SingleData &singleData, float fResizeRatio,
|
||
std::shared_ptr<ProcessData> pProcessData, Step1Location &step1Location)
|
||
{
|
||
uint32_t iOrigWidth = pProcessData->iWidth;
|
||
uint32_t iOrigHeight = pProcessData->iHeight;
|
||
|
||
singleData.fLTX = singleData.fLTX * fResizeRatio + step1Location.fLTX;
|
||
singleData.fLTY = singleData.fLTY * fResizeRatio + step1Location.fLTY;
|
||
singleData.fRBX = singleData.fRBX * fResizeRatio + step1Location.fLTX;
|
||
singleData.fRBY = singleData.fRBY * fResizeRatio + step1Location.fLTY;
|
||
|
||
singleData.fLTX = (singleData.fLTX < iOrigWidth) ? singleData.fLTX : iOrigWidth;
|
||
singleData.fLTY = (singleData.fLTY < iOrigHeight) ? singleData.fLTY : iOrigHeight;
|
||
singleData.fRBX = (singleData.fRBX < iOrigWidth) ? singleData.fRBX : iOrigWidth;
|
||
singleData.fRBY = (singleData.fRBY < iOrigHeight) ? singleData.fRBY : iOrigHeight;
|
||
}
|
||
}
|