zhangwei
/
Train_Identify
Template
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: zhangwei:ac73334039806a613d0594d30c0cc96668dba5f5
Branches Tags
zhangwei:main
zhangwei:Test
zhangwei:test
..
compare: zhangwei:34c0ccdfeea1f37a2368d0789dfa6b2167017574
Branches Tags
zhangwei:Test
zhangwei:main
zhangwei:test

No commits in common. "ac73334039806a613d0594d30c0cc96668dba5f5" and "34c0ccdfeea1f37a2368d0789dfa6b2167017574" have entirely different histories.
ac73334039 ... 34c0ccdfee

33 changed files with 961 additions and 912 deletions
Show Stats Expand all files Collapse all files

7
.gitignore vendored
View File

@ -1,7 +0,0 @@
/build/
/app/
*.tgz
*.tar
*.log
*.o
*.out

164
CMakeLists.txt
View File

@ -5,7 +5,7 @@ message("NVIDIA NX PLATFORM")
set(PROJECT_NAME train) set(PROJECT_NAME train)
project(${PROJECT_NAME} VERSION 1.0) project(${PROJECT_NAME} VERSION 1.0)
add_definitions(-std=c++11) add_definitions(-std=c++11)
add_definitions(-DAPI_EXPORTS) add_definitions(-DAPI_EXPORTS)
@ -20,8 +20,6 @@ find_package(OpenCV REQUIRED)
# message(STATUS "${OpenCV_LIBS}") # message(STATUS "${OpenCV_LIBS}")
# message(STATUS "${OpenCV_INCLUDE_DIRS}") # message(STATUS "${OpenCV_INCLUDE_DIRS}")
find_package(CUDA REQUIRED)
# 设置编译工具 # 设置编译工具
set(CMAKE_SYSTEM_NAME Linux) set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_C_COMPILER "gcc") set(CMAKE_C_COMPILER "gcc")
@ -41,19 +39,15 @@ set(SYS_USR_INCLUDE_DIR "/usr/include")
set(SYS_USR_LIB_DIR "/usr/lib") set(SYS_USR_LIB_DIR "/usr/lib")
set(SYS_USR_LOCAL_INCLUDE_DIR "/usr/local/include") set(SYS_USR_LOCAL_INCLUDE_DIR "/usr/local/include")
set(SYS_USR_LOCAL_LIB_DIR "/usr/local/lib") set(SYS_USR_LOCAL_LIB_DIR "/usr/local/lib")
# -- X86下使用 --
set(AARCH64_LINUX_INCLUDE_DIR "/usr/include/x86_64-linux-gnu") set(AARCH64_LINUX_INCLUDE_DIR "/usr/include/x86_64-linux-gnu")
set(AARCH64_LINUX_LIB_DIR "/usr/lib/x86_64-linux-gnu") set(AARCH64_LINUX_LIB_DIR "/usr/lib/x86_64-linux-gnu")
# -- ARM下使用 --
#set(AARCH64_LINUX_INCLUDE_DIR "/usr/include/aarch64-linux-gnu")
#set(AARCH64_LINUX_LIB_DIR "/usr/lib/aarch64-linux-gnu")
#opencv3.2.0的库文件在/usr/lib/aarch64-linux-gnu下 头文件路径在/usr/include/opencv2 #opencv3.2.0的库文件在/usr/lib/aarch64-linux-gnu下 头文件路径在/usr/include/opencv2
#opencv4.5.5的库文件在/usr/local/lib下 头文件路径在/usr/local/include/opencv4 #opencv4.5.5的库文件在/usr/local/lib下 头文件路径在/usr/local/include/opencv4
#目前使用最新版opencv4.5.5 #目前使用最新版opencv4.5.5
set(OPENCV_INCLUDE_DIR ${SYS_USR_LOCAL_INCLUDE_DIR}/opencv4) set(OPENCV_INCLUDE_DIR ${SYS_USR_LOCAL_INCLUDE_DIR}/opencv4)
set(OPENCV_LIB_DIR ${SYS_USR_LOCAL_LIB_DIR}) set(OPENCV_LIB_DIR ${SYS_USR_LOCAL_LIB_DIR})
set(CUDA_DIR "/usr/local/cuda-11.7") set(CUDA_DIR "/usr/local/cuda-11.7")
set(CUDA_INCLUDE_DIR ${CUDA_DIR}/include) set(CUDA_INCLUDE_DIR ${CUDA_DIR}/include)
@ -66,80 +60,80 @@ set(DRM_INCLUDE_DIR ${SYS_USR_INCLUDE_DIR}/libdrm) #DRM的头文件在/usr/incl
set(TEGRA_LIB_DIR ${AARCH64_LINUX_LIB_DIR}/tegra) #tegra库文件路径/usr/lib/aarch64-linux-gnu/tegra set(TEGRA_LIB_DIR ${AARCH64_LINUX_LIB_DIR}/tegra) #tegra库文件路径/usr/lib/aarch64-linux-gnu/tegra
#set(PCL_INCLUDE ${SYS_USR_LOCAL_INCLUDE_DIR}/pcl-1.7) #pcl头文件路径 set(PCL_INCLUDE ${SYS_USR_LOCAL_INCLUDE_DIR}/pcl-1.7) #pcl头文件路径
# nvidia ascend common include # nvidia ascend common include
include_directories( include_directories(
#ai_matrix include #ai_matrix include
${PROJECT_SOURCE_DIR}/ai_matrix ${PROJECT_SOURCE_DIR}/ai_matrix
${PROJECT_SOURCE_DIR}/ai_matrix/framework ${PROJECT_SOURCE_DIR}/ai_matrix/framework
${PROJECT_SOURCE_DIR}/ai_matrix/myftp ${PROJECT_SOURCE_DIR}/ai_matrix/myftp
${PROJECT_SOURCE_DIR}/ai_matrix/myhttp ${PROJECT_SOURCE_DIR}/ai_matrix/myhttp
${PROJECT_SOURCE_DIR}/ai_matrix/myJson ${PROJECT_SOURCE_DIR}/ai_matrix/myJson
${PROJECT_SOURCE_DIR}/ai_matrix/myJson/json ${PROJECT_SOURCE_DIR}/ai_matrix/myJson/json
${PROJECT_SOURCE_DIR}/ai_matrix/mylog ${PROJECT_SOURCE_DIR}/ai_matrix/mylog
${PROJECT_SOURCE_DIR}/ai_matrix/pcl ${PROJECT_SOURCE_DIR}/ai_matrix/pcl
${PROJECT_SOURCE_DIR}/ai_matrix/myqueue ${PROJECT_SOURCE_DIR}/ai_matrix/myqueue
${PROJECT_SOURCE_DIR}/ai_matrix/myshell ${PROJECT_SOURCE_DIR}/ai_matrix/myshell
${PROJECT_SOURCE_DIR}/ai_matrix/myutils ${PROJECT_SOURCE_DIR}/ai_matrix/myutils
#nvidia ascend common cann include #nvidia ascend common cann include
${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/BlockingQueue ${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/BlockingQueue
${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/CBase64 ${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/CBase64
${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/CommandParser ${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/CommandParser
${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/CommonDataType ${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/CommonDataType
${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/ConfigParser ${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/ConfigParser
${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/ErrorCode ${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/ErrorCode
${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/FileManager ${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/FileManager
${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/Log ${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/Log
${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/ ${PROJECT_SOURCE_DIR}/nvidia_ascend_base/Base/
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common
#common engine include #common engine include
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/ControlEngine ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/ControlEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DataSourceEngine ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DataSourceEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DataUploadEngine ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DataUploadEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/FilterEngine ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/FilterEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/MergerEngine ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/MergerEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/SaveEngine ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/PixelFormatConvertEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/SelectBestEngine ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/SaveEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/TrainAnaEngine ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/SelectBestEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/TransEngine ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/TrainAnaEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DataDealEngine ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/TransEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/SocketEngine ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DataDealEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DeleteExpiredFolderEngine ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/SocketEngine
#common tools rtsp_server include #common tools rtsp_server include
${PROJECT_SOURCE_DIR}/nvidia_ascend_tools/common_tools/rtsp_server/3rdpart/md5 ${PROJECT_SOURCE_DIR}/nvidia_ascend_tools/common_tools/rtsp_server/3rdpart/md5
${PROJECT_SOURCE_DIR}/nvidia_ascend_tools/common_tools/rtsp_server/net/ ${PROJECT_SOURCE_DIR}/nvidia_ascend_tools/common_tools/rtsp_server/net/
${PROJECT_SOURCE_DIR}/nvidia_ascend_tools/common_tools/rtsp_server/xop/ ${PROJECT_SOURCE_DIR}/nvidia_ascend_tools/common_tools/rtsp_server/xop/
) )
include_directories( include_directories(
#nvidia engine include #nvidia engine include
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/ChkDateStepOneEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/ChkDateStepTwoEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/ContainerEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/DecodeEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/MoveEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/MyYaml
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/TrainStepOneEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/TrainStepTwoEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/ChkDateStepOneEngine #nvidia_tools yolov5 include
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/ChkDateStepTwoEngine ${PROJECT_SOURCE_DIR}/nvidia_ascend_tools/nvidia_tools/yolov5/include
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/ContainerEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/DecodeEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/MoveEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/MyYaml
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/TrainStepOneEngine
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/TrainStepTwoEngine
#nvidia_tools yolov5 include #third party include
${PROJECT_SOURCE_DIR}/nvidia_ascend_tools/nvidia_tools/yolov5/include ${CUDA_INCLUDE_DIR}
${TENSORRT_INCLUDE_DIR}
#third party include ${DRM_INCLUDE_DIR}
${CUDA_INCLUDE_DIR} ${OpenCV_DIR}
${TENSORRT_INCLUDE_DIR} ${AARCH64_LINUX_INCLUDE_DIR}
${DRM_INCLUDE_DIR} ${SYS_USR_LOCAL_INCLUDE_DIR}
${OpenCV_DIR} ${PCL_INCLUDE}
${AARCH64_LINUX_INCLUDE_DIR}
${SYS_USR_LOCAL_INCLUDE_DIR}
# ${PCL_INCLUDE}
) )
@ -150,7 +144,7 @@ link_directories(${SYS_USR_LOCAL_LIB_DIR}
${CUDA_LIB_DIR} ${CUDA_LIB_DIR}
${TENSORRT_LIB_DIR} ${TENSORRT_LIB_DIR}
${TEGRA_LIB_DIR} ${TEGRA_LIB_DIR}
) )
#源文件 #源文件
#公共源文件 #公共源文件
@ -177,6 +171,7 @@ file(GLOB_RECURSE COMMON_SRCS_LISTS
#common engine src #common engine src
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common/*.cpp ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DataSourceEngine/*.cpp ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DataSourceEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/PixelFormatConvertEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/ControlEngine/*.cpp ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/ControlEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DataUploadEngine/*.cpp ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DataUploadEngine/*.cpp
@ -187,19 +182,26 @@ file(GLOB_RECURSE COMMON_SRCS_LISTS
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/TransEngine/*.cpp ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/TransEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DataDealEngine/*.cpp ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DataDealEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/SocketEngine/*.cpp ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/SocketEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/SocketEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DataSourceEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/SaveEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DeleteExpiredFolderEngine/*.cpp
#common tools rtsp_server src #common tools rtsp_server src
${PROJECT_SOURCE_DIR}/nvidia_ascend_tools/common_tools/rtsp_server/net/*.cpp ${PROJECT_SOURCE_DIR}/nvidia_ascend_tools/common_tools/rtsp_server/net/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_tools/common_tools/rtsp_server/xop/*.cpp ${PROJECT_SOURCE_DIR}/nvidia_ascend_tools/common_tools/rtsp_server/xop/*.cpp
) )
file(GLOB_RECURSE SRCS_LISTS file(GLOB_RECURSE SRCS_LISTS
#nvidia engine src #nvidia engine src
#nvidia engine include #nvidia engine include
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/ControlEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DataSourceEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DataUploadEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/FilterEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/MergerEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/PixelFormatConvertEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/SaveEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/SelectBestEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/TrainAnaEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/TransEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/common_engine/DataDealEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/ChkDateStepOneEngine/*.cpp ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/ChkDateStepOneEngine/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/ChkDateStepTwoEngine/*.cpp ${PROJECT_SOURCE_DIR}/nvidia_ascend_engine/nvidia_engine/ChkDateStepTwoEngine/*.cpp
@ -215,7 +217,7 @@ file(GLOB_RECURSE SRCS_LISTS
#nvidia tools yolov5 src #nvidia tools yolov5 src
${PROJECT_SOURCE_DIR}/nvidia_ascend_tools/nvidia_tools/yolov5/src/*.cpp ${PROJECT_SOURCE_DIR}/nvidia_ascend_tools/nvidia_tools/yolov5/src/*.cpp
${PROJECT_SOURCE_DIR}/nvidia_ascend_tools/nvidia_tools/yolov5/src/*.cu ${PROJECT_SOURCE_DIR}/nvidia_ascend_tools/nvidia_tools/yolov5/src/*.cu
) )
cuda_add_executable(${PROJECT_NAME} ${COMMON_SRCS_LISTS} ${SRCS_LISTS}) cuda_add_executable(${PROJECT_NAME} ${COMMON_SRCS_LISTS} ${SRCS_LISTS})
@ -225,11 +227,11 @@ target_link_libraries(${PROJECT_NAME} cudart cuda) #CUDA
target_link_libraries(${PROJECT_NAME} target_link_libraries(${PROJECT_NAME}
${OpenCV_LIBS} #third party librarys ${OpenCV_LIBS} #third party librarys
# ${PCL_LIBRARY_DIRS} ${PCL_LIBRARY_DIRS}
# pcl_common pcl_io_ply pcl_keypoints pcl_registration pcl_segmentation pcl_features pcl_io pcl_octree #pcl pcl_common pcl_io_ply pcl_keypoints pcl_registration pcl_segmentation pcl_features pcl_io pcl_octree #pcl
# pcl_sample_consensus pcl_surface pcl_filters pcl_kdtree pcl_recognition pcl_search pcl_tracking pcl_sample_consensus pcl_surface pcl_filters pcl_kdtree pcl_recognition pcl_search pcl_tracking
avformat avcodec avutil avfilter swresample swscale postproc #VideoCodecV2 avformat avcodec avutil avfilter swresample swscale postproc #VideoCodecV2
yaml-cpp https_sn yaml-cpp https_sn
jsoncpp curl boost_system boost_filesystem ssh2 jsoncpp curl boost_system boost_filesystem ssh2
-Wl,-z,relro,-z,now,-z,noexecstack -pie -s -Wl,-z,relro,-z,now,-z,noexecstack -pie -s
) )

99
ai_matrix/myutils/myutils.cpp
View File

@ -129,37 +129,37 @@ namespace ai_matrix
return std::string(tmp); return std::string(tmp);
} }
std::string MyUtils::get_date() std::string MyUtils::get_date()
{ {
time_t timep = time(NULL); time_t timep = time(NULL);
struct tm *p = localtime(&timep); struct tm *p = localtime(&timep);
struct timeval tv; struct timeval tv;
gettimeofday(&tv, NULL); gettimeofday(&tv, NULL);
int msec = tv.tv_usec / 1000; int msec = tv.tv_usec / 1000;
char tmp[12] = { 0 }; char tmp[12] = { 0 };
sprintf(tmp, "%04d-%02d-%02d", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday); sprintf(tmp, "%04d-%02d-%02d", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday);
return std::string(tmp); return std::string(tmp);
} }
std::string MyUtils::get_time() std::string MyUtils::get_time()
{ {
time_t timep = time(NULL); time_t timep = time(NULL);
struct tm *p = localtime(&timep); struct tm *p = localtime(&timep);
struct timeval tv; struct timeval tv;
gettimeofday(&tv, NULL); gettimeofday(&tv, NULL);
int msec = tv.tv_usec / 1000; int msec = tv.tv_usec / 1000;
char tmp[10] = { 0 }; char tmp[10] = { 0 };
sprintf(tmp, "%02d-%02d-%02d", p->tm_hour, p->tm_min, p->tm_sec); sprintf(tmp, "%02d-%02d-%02d", p->tm_hour, p->tm_min, p->tm_sec);
return std::string(tmp); return std::string(tmp);
} }
std::string MyUtils::get_timestamp_log() std::string MyUtils::get_timestamp_log()
{ {
@ -310,12 +310,12 @@ namespace ai_matrix
return buffer.str(); return buffer.str();
} }
/** /**
* 拷贝文件 * 拷贝文件
* @param filePath 源文件位置 * @param filePath 源文件位置
* @param savePath 将要拷贝的新位置 * @param savePath 将要拷贝的新位置
* @return * @return
*/ */
bool MyUtils::copyFile(std::string filePath, std::string savePath) bool MyUtils::copyFile(std::string filePath, std::string savePath)
{ {
FILE *fp, *sp; FILE *fp, *sp;
@ -338,14 +338,14 @@ namespace ai_matrix
} }
std::string& MyUtils::replace_all_distinct(std::string &str, const std::string &old_value, const std::string &new_value) 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()) { 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) if ((pos = str.find(old_value, pos)) != std::string::npos)
str.replace(pos, old_value.length(), new_value); str.replace(pos, old_value.length(), new_value);
else break; else break;
} }
return str; return str;
} }
/** /**
* 获取北京当前日期 * 获取北京当前日期
@ -386,23 +386,6 @@ namespace ai_matrix
return std::string(szTmp); 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年的毫秒数 * 获取当前时间距1970年的毫秒数
* inParam : N/A * inParam : N/A
@ -524,7 +507,7 @@ namespace ai_matrix
return true; return true;
} }
#ifdef ASCEND #ifdef ASCEND
/** /**
* 拷贝Device数据到Host * 拷贝Device数据到Host
* inParam : void *pDeviceBuffer device内存地址 * inParam : void *pDeviceBuffer device内存地址
@ -606,8 +589,8 @@ namespace ai_matrix
} }
return true; return true;
} }
#endif #endif
/** /**
* 获取指定毫秒数的对应的北京日期时间 * 获取指定毫秒数的对应的北京日期时间
* inParam : uint64_t i64MilliSeconds * inParam : uint64_t i64MilliSeconds
@ -670,7 +653,7 @@ namespace ai_matrix
} }
if (!ifs.is_open()) if (!ifs.is_open())
{ {
// LogWarn << "txt:" << strFilePath << " open fail"; LogWarn << "txt:" << strFilePath << " open fail";
return false; return false;
} }
@ -752,7 +735,7 @@ namespace ai_matrix
} }
//清空之前的结果 //清空之前的结果
vecResult.clear(); vecResult.clear();
// 每个类别中，获取得分最高的框 // 每个类别中，获取得分最高的框
for (auto iter = mapResult.begin(); iter != mapResult.end(); iter++) for (auto iter = mapResult.begin(); iter != mapResult.end(); iter++)
{ {

33
ai_matrix/myutils/myutils.h
View File

@ -51,13 +51,10 @@ namespace ai_matrix
//获取时间戳 //获取时间戳
std::string get_timestamp_file(); std::string get_timestamp_file();
std::string get_timestamp_log(); std::string get_timestamp_log();
//获取日期 //获取日期
std::string get_date(); std::string get_date();
//获取时间 //获取时间
std::string get_time(); std::string get_time();
//时间戳转化为时间 毫秒级
std::string Stamp2Time(long long timestamp, bool has_msec = false);
//创建文件夹 //创建文件夹
std::string create_dir_name(std::string root, std::string name); std::string create_dir_name(std::string root, std::string name);
@ -76,16 +73,16 @@ namespace ai_matrix
//bool 转 string //bool 转 string
std::string getStringFromBool(bool b); std::string getStringFromBool(bool b);
/** /**
* 拷贝文件 * 拷贝文件
* @param filePath 源文件位置 * @param filePath 源文件位置
* @param savePath 将要拷贝的新位置 * @param savePath 将要拷贝的新位置
* @return * @return
*/ */
bool copyFile(std::string filePath, std::string savePath); bool copyFile(std::string filePath, std::string savePath);
//替换string中所有指定字符串 //替换string中所有指定字符串
std::string& replace_all_distinct(std::string &str, const std::string &old_value, const std::string &new_value); std::string& replace_all_distinct(std::string &str, const std::string &old_value, const std::string &new_value);
//获取北京当前日期 //获取北京当前日期
std::string GetDate(); std::string GetDate();
@ -102,13 +99,13 @@ namespace ai_matrix
//创建文件夹路径 //创建文件夹路径
bool CreateDirPath(std::string strDirPath); bool CreateDirPath(std::string strDirPath);
#ifdef ASCEND #ifdef ASCEND
//拷贝Device数据到Host //拷贝Device数据到Host
bool MemcpyDeviceToHost(std::shared_ptr<void> *pHostData, const void *pDeviceBuffer, uint32_t iBufferSize); bool MemcpyDeviceToHost(std::shared_ptr<void> *pHostData, const void *pDeviceBuffer, uint32_t iBufferSize);
//拷贝Host数据到Device //拷贝Host数据到Device
bool MemcpyHostToDevice(std::shared_ptr<void> *pDeviceData, const void *pHostBuffer, uint32_t iBufferSize, bool bDvppFlag = true); bool MemcpyHostToDevice(std::shared_ptr<void> *pDeviceData, const void *pHostBuffer, uint32_t iBufferSize, bool bDvppFlag = true);
#endif #endif
//获取指定毫秒数的对应的日期时间 //获取指定毫秒数的对应的日期时间
std::string GetDateTimeByMilliSeconds(uint64_t i64MilliSeconds, bool bFormatFlag = false); std::string GetDateTimeByMilliSeconds(uint64_t i64MilliSeconds, bool bFormatFlag = false);

BIN
app/train
View File

Binary file not shown.

5
config.yaml
View File

@ -113,8 +113,6 @@ model:
nms_threshold: 0.3 nms_threshold: 0.3
gc_http_open: 1 gc_http_open: 1
username: "guest_01"
password: "d55b0f642e817eea24725d2f2a31dd08" # 神东
gc_http_url: "http://192.168.2.211:20004/api/train-carriage/identification/video-save" gc_http_url: "http://192.168.2.211:20004/api/train-carriage/identification/video-save"
gc_gettoken_url: "http://192.168.2.211:20004/api/blade-auth/oauth/token" gc_gettoken_url: "http://192.168.2.211:20004/api/blade-auth/oauth/token"
gc_image_srv: "http://192.168.2.211:9010/" gc_image_srv: "http://192.168.2.211:9010/"
@ -181,6 +179,3 @@ gc_c_space_frame_width: 500
# 是否识别车头 # 是否识别车头
gc_train_heard_detect: true gc_train_heard_detect: true
#过期文件夹天数
gc_days_for_result_expire_folder: 3

1
matrix.yaml
View File

@ -55,7 +55,6 @@ engines:
DeviceStatusUpSerEngine: 0 DeviceStatusUpSerEngine: 0
#ResultToMySQLSrvEngine: 0 #ResultToMySQLSrvEngine: 0
#DataToMinioSrvEngine: 0 #DataToMinioSrvEngine: 0
DeleteExpiredFolderEngine: 0
#engine连接 #engine连接
connects: connects:

29
nvidia_ascend_engine/common_engine/DataDealEngine/DataDealEngine.cpp
View File

@ -118,7 +118,7 @@ bool DataDealEngine::ReadFileInfo(Json::Value &jvFrameInfo, RawData &rawData, st
// LogError << "Failed to read image:" << strImgName; // LogError << "Failed to read image:" << strImgName;
// return false; // return false;
// } // }
return true; return true;
} }
@ -191,13 +191,13 @@ void DataDealEngine::MakeProcessData()
} }
LogInfo << "sourceid:" << iSourceId << " MakeProcessData origtime:" << moveData_.strTrainName << " iOrigFrameId:" << iOrigFrameId LogInfo << "sourceid:" << iSourceId << " MakeProcessData origtime:" << moveData_.strTrainName << " iOrigFrameId:" << iOrigFrameId
<< " time:" << strTrainName_ << " iFrameId:" << iFrameId << " bIsEndFlag:" << bIsEndFlag; << " time:" << strTrainName_ << " iFrameId:" << iFrameId << " bIsEndFlag:" << bIsEndFlag;
std::string strImgName = strDataDir_ + szCameraNo + std::to_string(iOrigFrameId); std::string strImgName = strDataDir_ + szCameraNo + std::to_string(iOrigFrameId);
strImgName += (iter->second.iRotate != 0) ? "_rotate.jpg" : ".jpg"; strImgName += (iter->second.iRotate != 0) ? "_rotate.jpg" : ".jpg";
std::string strFileName = strDataDir_ + szCameraNo + std::to_string(iOrigFrameId) + ".txt"; std::string strFileName = strDataDir_ + szCameraNo + std::to_string(iOrigFrameId) + ".txt";
//摄像头读取失败后重试30次。 //摄像头读取失败后重试2000次。
Json::Value jvFrameInfo; Json::Value jvFrameInfo;
RawData rawData; RawData rawData;
bool bRet = false; bool bRet = false;
@ -228,7 +228,7 @@ void DataDealEngine::MakeProcessData()
pProcessData->bIsEnd = bIsEndFlag; pProcessData->bIsEnd = bIsEndFlag;
pProcessData->iDataNO = iDataNO_; pProcessData->iDataNO = iDataNO_;
pProcessData->nMonitorState = moveData_.nMonitorState; pProcessData->nMonitorState = moveData_.nMonitorState;
if (bRet) if (bRet)
{ {
i64TimeStampTemp = jvFrameInfo["timeStamp"].asUInt64(); i64TimeStampTemp = jvFrameInfo["timeStamp"].asUInt64();
@ -241,7 +241,7 @@ void DataDealEngine::MakeProcessData()
cv::Mat cvframe = cv::imread(pProcessData->strPicFilePath); cv::Mat cvframe = cv::imread(pProcessData->strPicFilePath);
int iBufferSize = pProcessData->iWidth * pProcessData->iHeight * 3; int iBufferSize = pProcessData->iWidth * pProcessData->iHeight * 3;
void* pBGRBufferobj = nullptr; void* pBGRBufferobj = nullptr;
pBGRBufferobj = new uint8_t[iBufferSize]; pBGRBufferobj = new uint8_t[iBufferSize];
memcpy(pBGRBufferobj, cvframe.data, iBufferSize); memcpy(pBGRBufferobj, cvframe.data, iBufferSize);
pProcessData->pData.reset(pBGRBufferobj, [](void* data){if(data) {delete[] data; data = nullptr;}}); pProcessData->pData.reset(pBGRBufferobj, [](void* data){if(data) {delete[] data; data = nullptr;}});
pProcessData->iSize = iBufferSize; pProcessData->iSize = iBufferSize;
@ -255,15 +255,15 @@ void DataDealEngine::MakeProcessData()
//iRet = outputQueMap_[vecPushPorts[iPort]]->push(std::static_pointer_cast<void>(pProcessData)); //iRet = outputQueMap_[vecPushPorts[iPort]]->push(std::static_pointer_cast<void>(pProcessData));
PushData(vecPushPorts[iPort], pProcessData); PushData(vecPushPorts[iPort], pProcessData);
continue; continue;
} }
std::shared_ptr<ProcessData> pNewProcessData = std::make_shared<ProcessData>(); std::shared_ptr<ProcessData> pNewProcessData = std::make_shared<ProcessData>();
*pNewProcessData = *pProcessData; *pNewProcessData = *pProcessData;
//iRet = outputQueMap_[vecPushPorts[iPort]]->push(std::static_pointer_cast<void>(pNewProcessData)); //iRet = outputQueMap_[vecPushPorts[iPort]]->push(std::static_pointer_cast<void>(pNewProcessData));
PushData(vecPushPorts[iPort], pNewProcessData); PushData(vecPushPorts[iPort], pNewProcessData);
} }
} }
iOrigDataNO_++; iOrigDataNO_++;
iDataNO_++; iDataNO_++;
//每组处理数据需间隔一定时间 //每组处理数据需间隔一定时间
@ -291,25 +291,14 @@ APP_ERROR DataDealEngine::Process()
//获取主摄像头检测的状态 //获取主摄像头检测的状态
std::shared_ptr<void> pVoidData0 = nullptr; std::shared_ptr<void> pVoidData0 = nullptr;
iRet = inputQueMap_[strPort0_]->pop(pVoidData0); iRet = inputQueMap_[strPort0_]->pop(pVoidData0);
if (nullptr != pVoidData0) if (nullptr != pVoidData0)
{ {
std::shared_ptr<MoveData> pMoveData = std::static_pointer_cast<MoveData>(pVoidData0); std::shared_ptr<MoveData> pMoveData = std::static_pointer_cast<MoveData>(pVoidData0);
// queuwMoveData_.push(*pMoveData);
moveData_ = *pMoveData; moveData_ = *pMoveData;
LogDebug << "traindate:" << moveData_.strTrainDate << " trainname:" << moveData_.strTrainName LogDebug << "traindate:" << moveData_.strTrainDate << " trainname:" << moveData_.strTrainName
<< " MoveData frameid:" << moveData_.iFrameId << " IsEnd:" << moveData_.bIsEnd; << " MoveData frameid:" << moveData_.iFrameId << " IsEnd:" << moveData_.bIsEnd;
} }
// LogDebug << "【帧号】" << (iDataNO_ * dataSourceConfig_.iSkipInterval);
// if (queuwMoveData_.size() > 0 && (iDataNO_ * dataSourceConfig_.iSkipInterval) >= queuwMoveData_.front().iFrameId)
// {
// moveData_ = queuwMoveData_.front();
// queuwMoveData_.pop();
// LogDebug << "!!!--- moveDate 更新";
// }
if (!moveData_.bHasTrain) if (!moveData_.bHasTrain)
{ {
usleep(1000); //1ms usleep(1000); //1ms
@ -319,7 +308,7 @@ APP_ERROR DataDealEngine::Process()
//第一个数据，休眠1s，等待图片存入本地 //第一个数据，休眠1s，等待图片存入本地
if (iOrigDataNO_ == 1) if (iOrigDataNO_ == 1)
{ {
usleep(1000 * 1000); //1s usleep(1000000); //1s
} }
if (strDataDir_.empty()) if (strDataDir_.empty())

18
nvidia_ascend_engine/common_engine/DataDealEngine/DataDealTwoEngine.cpp
View File

@ -239,8 +239,8 @@ void DataDealTwoEngine::GetMainSplitInfo(Json::Value &jvMainSplit, std::shared_p
{ {
iValidType = pProcessData->iDirection == DIRECTION_LEFT ? VALID_LEFT : VALID_RIGHT; iValidType = pProcessData->iDirection == DIRECTION_LEFT ? VALID_LEFT : VALID_RIGHT;
} }
LogDebug << " frameid:" << pProcessData->iFrameId LogDebug << "sourceid:" << pProcessData->iDataSource << " frameid:" << pProcessData->iFrameId
<< " 车节:" << pProcessData->iTrainIndex << " iSpaceType_:" << iSpaceType_ << " trainIndex:" << pProcessData->iTrainIndex << " iSpaceType_:" << iSpaceType_
<< " iSpaceX:" << iSpaceX << " iLastSpaceX_:" << iLastSpaceX_ << " iSpaceX:" << iSpaceX << " iLastSpaceX_:" << iLastSpaceX_
<< " iLastSpaceFrameid_:" << iLastSpaceFrameid_ << " bIntervalFlag:" << bIntervalFlag; << " iLastSpaceFrameid_:" << iLastSpaceFrameid_ << " bIntervalFlag:" << bIntervalFlag;
iLastSpaceX_ = iSpaceX; iLastSpaceX_ = iSpaceX;
@ -352,11 +352,11 @@ void DataDealTwoEngine::GetValidTypeAndSplit(Json::Value &jvOneSplit, Json::Valu
GetSubSplitInfoByMain(jvOneSplit, pProcessData, jvFrameInfo); GetSubSplitInfoByMain(jvOneSplit, pProcessData, jvFrameInfo);
} }
// LogDebug << "sourceid:" << pProcessData->iDataSource << " frameid:" << pProcessData->iFrameId LogDebug << "sourceid:" << pProcessData->iDataSource << " frameid:" << pProcessData->iFrameId
// << " trainIndex:" << pProcessData->iTrainIndex << " trainIndex:" << pProcessData->iTrainIndex
// << " validType:" << jvOneSplit["validType"].asInt() << " splitX:" << jvOneSplit["splitX"].asInt() << " validType:" << jvOneSplit["validType"].asInt() << " splitX:" << jvOneSplit["splitX"].asInt()
// << " needNum:" << jvOneSplit["needNum"].asBool() << " needPro:" << jvOneSplit["needPro"].asBool() << " needNum:" << jvOneSplit["needNum"].asBool() << " needPro:" << jvOneSplit["needPro"].asBool()
// << " needChkDate:" << jvOneSplit["needChkDate"].asBool() << " needContainer:" << jvOneSplit["needContainer"].asBool(); << " needChkDate:" << jvOneSplit["needChkDate"].asBool() << " needContainer:" << jvOneSplit["needContainer"].asBool();
} }
/** /**
@ -456,8 +456,8 @@ void DataDealTwoEngine::MakeProcessData(std::shared_ptr<TrainRange> pTrainRange)
sprintf(szCameraNo, "%03d/", iSourceId + 1); sprintf(szCameraNo, "%03d/", iSourceId + 1);
bool bIsEndFlag = (pTrainRange->iEndFrameId == iFrameId); bool bIsEndFlag = (pTrainRange->iEndFrameId == iFrameId);
// LogInfo << "sourceid:" << iSourceId << " StepTwo MakeProcessData trainIndex:" << pTrainRange->iTrainIndex LogInfo << "sourceid:" << iSourceId << " StepTwo MakeProcessData trainIndex:" << pTrainRange->iTrainIndex
// << " iFrameId:" << iFrameId << " bIsEndFlag:" << bIsEndFlag; << " iFrameId:" << iFrameId << " bIsEndFlag:" << bIsEndFlag;
std::string strImgName = strDataDir + szCameraNo + std::to_string(iFrameId); std::string strImgName = strDataDir + szCameraNo + std::to_string(iFrameId);
strImgName += (iter->second.iRotate != 0) ? "_rotate.jpg" : ".jpg"; strImgName += (iter->second.iRotate != 0) ? "_rotate.jpg" : ".jpg";
std::string strFileName = strDataDir + szCameraNo + std::to_string(iFrameId) + ".txt"; std::string strFileName = strDataDir + szCameraNo + std::to_string(iFrameId) + ".txt";

2
nvidia_ascend_engine/common_engine/DataSourceEngine/CameraEngine.cpp
View File

@ -7,7 +7,7 @@ namespace
{ {
const int LOW_THRESHOLD = 128; const int LOW_THRESHOLD = 128;
const int MAX_THRESHOLD = 4096; const int MAX_THRESHOLD = 4096;
const uint16_t DELAY_TIME = 10000; const uint16_t DELAY_TIME = 40000;
} }
CameraEngine::CameraEngine() {} CameraEngine::CameraEngine() {}

17
nvidia_ascend_engine/common_engine/DataUploadEngine/ResultToHttpSrvEngine.cpp
View File

@ -8,8 +8,6 @@ ResultToHttpSrvEngine::~ResultToHttpSrvEngine() {}
APP_ERROR ResultToHttpSrvEngine::Init() APP_ERROR ResultToHttpSrvEngine::Init()
{ {
strPort0_ = engineName_ + "_" + std::to_string(engineId_) + "_0"; strPort0_ = engineName_ + "_" + std::to_string(engineId_) + "_0";
strUsername_ = MyYaml::GetIns()->GetStringValue("username");
strPassword_ = MyYaml::GetIns()->GetStringValue("password");
strURL_ = MyYaml::GetIns()->GetStringValue("gc_http_url"); strURL_ = MyYaml::GetIns()->GetStringValue("gc_http_url");
strGetTokenURL_ = MyYaml::GetIns()->GetStringValue("gc_gettoken_url"); strGetTokenURL_ = MyYaml::GetIns()->GetStringValue("gc_gettoken_url");
strImageSrv_ = MyYaml::GetIns()->GetPathValue("gc_image_srv"); strImageSrv_ = MyYaml::GetIns()->GetPathValue("gc_image_srv");
@ -78,11 +76,11 @@ bool ResultToHttpSrvEngine::GetToken(std::string &strBladeAuth)
curl_mime *pMultipart = curl_mime_init(pCurl_); curl_mime *pMultipart = curl_mime_init(pCurl_);
curl_mimepart *pPart = curl_mime_addpart(pMultipart); curl_mimepart *pPart = curl_mime_addpart(pMultipart);
curl_mime_name(pPart, "username"); curl_mime_name(pPart, "username");
curl_mime_data(pPart, strUsername_.c_str(), CURL_ZERO_TERMINATED); curl_mime_data(pPart, "guest_01", CURL_ZERO_TERMINATED);
pPart = curl_mime_addpart(pMultipart); pPart = curl_mime_addpart(pMultipart);
curl_mime_name(pPart, "password"); curl_mime_name(pPart, "password");
curl_mime_data(pPart, strPassword_.c_str(), CURL_ZERO_TERMINATED); curl_mime_data(pPart, "d55b0f642e817eea24725d2f2a31dd08", CURL_ZERO_TERMINATED);
pPart = curl_mime_addpart(pMultipart); pPart = curl_mime_addpart(pMultipart);
curl_mime_name(pPart, "tenantId"); curl_mime_name(pPart, "tenantId");
curl_mime_data(pPart, "000000", CURL_ZERO_TERMINATED); curl_mime_data(pPart, "000000", CURL_ZERO_TERMINATED);
pPart = curl_mime_addpart(pMultipart); pPart = curl_mime_addpart(pMultipart);
@ -278,8 +276,8 @@ void ResultToHttpSrvEngine::DealHttpFailInfo()
if (!ResultToHttpSrv(jvRequest)) if (!ResultToHttpSrv(jvRequest))
{ {
LogError << "re http post err:" << strLine; LogError << "re http post err:" << strLine;
//SaveHttpFailInfo(jvRequest, strFailSaveBakPath_); SaveHttpFailInfo(jvRequest, strFailSaveBakPath_);
// bAllSucc = false; bAllSucc = false;
continue; continue;
} }
} }
@ -428,11 +426,10 @@ APP_ERROR ResultToHttpSrvEngine::Process()
jvRequest["isTheLast"] = pTrain->bIsEnd ? 1 : 0; // 是否最后一节: 0:否,1:是 jvRequest["isTheLast"] = pTrain->bIsEnd ? 1 : 0; // 是否最后一节: 0:否,1:是
jvRequest["startFrame"] = pTrain->iStartFrameId; //车厢开始帧 jvRequest["startFrame"] = pTrain->iStartFrameId; //车厢开始帧
jvRequest["endFrame"] = pTrain->iEndFrameId; //车厢结束帧 jvRequest["endFrame"] = pTrain->iEndFrameId; //车厢结束帧
jvRequest["skipFrame"] = dataSourceConfig.iSkipInterval; jvRequest["skipFrame"] = dataSourceConfig.iSkipInterval; //跳帧
jvRequest["collectTime"] = MyUtils::getins()->Stamp2Time(pTrain->i64EndTimeStamp, true);//车厢切分的时间 //跳帧
if (!ResultToHttpSrv(jvRequest)) if (!ResultToHttpSrv(jvRequest))
{ {
// SaveHttpFailInfo(jvRequest, strFailSavePath_); SaveHttpFailInfo(jvRequest, strFailSavePath_);
} }
//列车结束后再次处理失败的信息 //列车结束后再次处理失败的信息

2
nvidia_ascend_engine/common_engine/DataUploadEngine/ResultToHttpSrvEngine.h
View File

@ -40,8 +40,6 @@ private:
bool SaveHttpFailInfo(Json::Value &jvRequest, std::string &strFilePath); bool SaveHttpFailInfo(Json::Value &jvRequest, std::string &strFilePath);
std::string strPort0_; std::string strPort0_;
std::string strUsername_;
std::string strPassword_;
std::string strURL_; std::string strURL_;
std::string strGetTokenURL_; std::string strGetTokenURL_;
std::string strImageSrv_; std::string strImageSrv_;

187
nvidia_ascend_engine/common_engine/DeleteExpiredFolderEngine/DeleteExpiredFolderEngine.cpp
View File

@ -1,187 +0,0 @@
#include "DeleteExpiredFolderEngine.h"
using namespace ai_matrix;
DeleteExpiredFolderEngine::DeleteExpiredFolderEngine() {}
DeleteExpiredFolderEngine::~DeleteExpiredFolderEngine() {}
APP_ERROR DeleteExpiredFolderEngine::Init()
{
iDaysNumber_ = MyYaml::GetIns()->GetIntValue("gc_days_for_result_expire_folder");
strResultPath_ = MyYaml::GetIns()->GetPathValue("gc_result_path");
LogInfo << "DeleteExpiredFolderEngine Init ok";
return APP_ERR_OK;
}
APP_ERROR DeleteExpiredFolderEngine::DeInit()
{
LogInfo << "DeleteExpiredFolderEngine DeInit ok";
return APP_ERR_OK;
}
APP_ERROR DeleteExpiredFolderEngine::Process()
{
int iRet = APP_ERR_OK;
while (!isStop_)
{
std::string strTrainDate_temp = MyUtils::getins()->GetDate();
DeletePreviousFolder(strResultPath_, strTrainDate_temp, iDaysNumber_);
usleep(1000*1000*3600*24); //每二十四小时执行一次
}
return APP_ERR_OK;
}
void DeleteExpiredFolderEngine::DeletePreviousFolder(std::string path, const std::string &date, int n_days)
{
// 1 computer date
std::string previous_date = getDateBeforeNDays(date, n_days);
if (!previous_date.empty())
std::cout << "Date before " << n_days << " days from " << date << " is: " << previous_date << std::endl;
// 2
std::vector<Date> subfolders;
GetSubfolderNames(path, subfolders);
// for (const auto &it : subfolders)
// std::cout << it.year << "." << it.month << "." << it.day << std::endl;
// 3 delete
if (path.back() != '/')
path += "/";
Date reference_date = StrToDate(previous_date); // 给定的参考日期
DeleteEarlierDatesFolder(path, subfolders, reference_date);
}
// 获取某月有多少天
int DeleteExpiredFolderEngine::DaysInMonth(int year, int month)
{
int max_days[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0))
{
max_days[2] = 29; // 闰年2月有29天
}
return max_days[month];
}
// 解析字符串为日期结构体
Date DeleteExpiredFolderEngine::StrToDate(const std::string &date_str)
{
std::istringstream iss(date_str);
int year, month, day;
char dash;
if (!(iss >> year >> dash && dash == '-' &&
iss >> month >> dash && dash == '-' &&
iss >> day))
{
LogError << ("Invalid date format") << ":" << date_str;
}
return {year, month, day};
}
// 减去指定天数
void DeleteExpiredFolderEngine::SubtractDays(Date &date, int n_days)
{
while (n_days > 0)
{
date.day--;
n_days--;
if (date.day == 0)
{
if (--date.month == 0)
{
--date.year;
date.month = 12;
}
int max_days = DaysInMonth(date.year, date.month);
date.day = max_days;
}
}
}
// 格式化日期结构体为字符串
std::string DeleteExpiredFolderEngine::DateToStr(const Date &date)
{
std::ostringstream oss;
oss << date.year << "-" << std::setfill('0') << std::setw(2) << date.month << "-" << std::setw(2) << date.day;
return oss.str();
}
// 主要功能函数，接收一个日期字符串和一个整数n，返回n天前的日期字符串
std::string DeleteExpiredFolderEngine::getDateBeforeNDays(const std::string &input_date, int n_days)
{
try
{
Date date = StrToDate(input_date);
SubtractDays(date, n_days);
return DateToStr(date);
}
catch (const std::exception &e)
{
LogError << "Error: " << e.what();
return "";
}
}
void DeleteExpiredFolderEngine::GetSubfolderNames(std::string &directory, std::vector<Date> &folder_names)
{
if (directory.back() != '/')
directory += "/";
DIR *dir;
struct dirent *ent;
if ((dir = opendir(directory.c_str())) != nullptr)
{
while ((ent = readdir(dir)) != nullptr)
{
// 排除"."和".."
if (ent->d_type == DT_DIR && ent->d_name[0] != '.' && ent->d_name == "best")
{
folder_names.push_back(StrToDate(ent->d_name));
}
}
closedir(dir);
}
else
{
LogError << "Unable to open directory: " << directory;
}
}
void DeleteExpiredFolderEngine::DeleteFolder(const std::string directory)
{
std::string command = "rm -rf " + directory;
int result = system(command.c_str());
if (result != 0)
std::cout << "Failed to remove directory recursively: " << directory << std::endl;
else
std::cout << "delete folder successfully : " << directory << std::endl;
}
// 删除向量中小于指定日期的所有元素
void DeleteExpiredFolderEngine::DeleteEarlierDatesFolder(std::string &path, std::vector<Date> &subfolders, const Date &reference_date)
{
if (path.back() != '/')
path += "/";
for (const Date &cur : subfolders)
{
// bool flag = false;
if (cur.year < reference_date.year)
{
DeleteFolder(path + DateToStr(cur));
}
else if (cur.year == reference_date.year && cur.month < reference_date.month)
{
DeleteFolder(path + DateToStr(cur));
}
else if (cur.year == reference_date.year && cur.month == reference_date.month && cur.day < reference_date.day)
{
DeleteFolder(path + DateToStr(cur));
}
}
}

57
nvidia_ascend_engine/common_engine/DeleteExpiredFolderEngine/DeleteExpiredFolderEngine.h
View File

@ -1,57 +0,0 @@
/**
* 过期数据删除引擎
**/
#ifndef DELETEEXPIREDFOLDERENGINE_H
#define DELETEEXPIREDFOLDERENGINE_H
#include "AppCommon.h"
#include "EngineBase.h"
#include "EngineFactory.h"
#include "MyYaml.h"
#include "myutils.h"
// 定义日期结构体
struct Date
{
int year;
int month;
int day;
};
class DeleteExpiredFolderEngine : public ai_matrix::EngineBase
{
public:
DeleteExpiredFolderEngine();
~DeleteExpiredFolderEngine();
APP_ERROR Init() override;
APP_ERROR DeInit() override;
APP_ERROR Process() override;
private:
// 获取某月有多少天
int DaysInMonth(int year, int month);
// 解析字符串为日期结构体
Date StrToDate(const std::string &date_str);
// 减去指定天数
void SubtractDays(Date &date, int n_days);
// 格式化日期结构体为字符串
std::string DateToStr(const Date &date);
// 接收一个日期字符串和一个整数n，返回n天前的日期字符串
std::string getDateBeforeNDays(const std::string &input_date, int n_days);
void GetSubfolderNames(std::string &directory, std::vector<Date> &folder_names);
void DeleteFolder(const std::string directory);
// 删除向量中小于指定日期的所有元素
void DeleteEarlierDatesFolder(std::string &path, std::vector<Date> &subfolders, const Date &reference_date);
void DeletePreviousFolder(std::string path, const std::string &date, int n_days);
private:
std::string strResultPath_;
int iDaysNumber_;
};
ENGINE_REGIST(DeleteExpiredFolderEngine)
#endif

204
nvidia_ascend_engine/common_engine/FilterEngine/FilterTrainStepOneEngine.cpp
View File

@ -28,9 +28,6 @@ APP_ERROR FilterTrainStepOneEngine::Init()
strResultPath_ = MyYaml::GetIns()->GetPathValue("gc_result_path"); strResultPath_ = MyYaml::GetIns()->GetPathValue("gc_result_path");
iChkStopPX_ = MyYaml::GetIns()->GetIntValue("gc_chkstop_px"); iChkStopPX_ = MyYaml::GetIns()->GetIntValue("gc_chkstop_px");
iChkStopCount_ = MyYaml::GetIns()->GetIntValue("gc_chkstop_count"); iChkStopCount_ = MyYaml::GetIns()->GetIntValue("gc_chkstop_count");
iPartitionFrameNum_ = MyYaml::GetIns()->GetIntValue("partition_frame_span");
iPlitFrameSpanPX_ = MyYaml::GetIns()->GetIntValue("gc_split_frame_span_px");
iPushDirection_ = MyYaml::GetIns()->GetIntValue("gc_push_direction");
//获取主摄像头信息 //获取主摄像头信息
mainCfg_ = MyYaml::GetIns()->GetDataSourceConfigById(0); mainCfg_ = MyYaml::GetIns()->GetDataSourceConfigById(0);
@ -38,8 +35,6 @@ APP_ERROR FilterTrainStepOneEngine::Init()
std::map<int, ai_matrix::DataSourceConfig> mapUseDataSouceCfg = MyYaml::GetIns()->GetUseDataSourceConfig(); std::map<int, ai_matrix::DataSourceConfig> mapUseDataSouceCfg = MyYaml::GetIns()->GetUseDataSourceConfig();
for (auto iter = mapUseDataSouceCfg.begin(); iter != mapUseDataSouceCfg.end(); iter++) for (auto iter = mapUseDataSouceCfg.begin(); iter != mapUseDataSouceCfg.end(); iter++)
{ {
this->rightFirst_ = iter->second.iRightFirst;
this->leftFirst_ = iter->second.iLeftFirst;
if (iter->second.strTarget.find("NUM") != std::string::npos) if (iter->second.strTarget.find("NUM") != std::string::npos)
{ {
LogDebug << "DataSource:" << iter->first << " deal NUM"; LogDebug << "DataSource:" << iter->first << " deal NUM";
@ -60,8 +55,8 @@ APP_ERROR FilterTrainStepOneEngine::Init()
mapTargetStr_.insert(std::make_pair(NUM, "NUM")); mapTargetStr_.insert(std::make_pair(NUM, "NUM"));
mapTargetStr_.insert(std::make_pair(PRO, "PRO")); mapTargetStr_.insert(std::make_pair(PRO, "PRO"));
mapTargetStr_.insert(std::make_pair(HEAD, "HEAD")); mapTargetStr_.insert(std::make_pair(HEAD, "HEAD"));
mapTargetStr_.insert(std::make_pair(SPACE, "SPACE"));//SPACE mapTargetStr_.insert(std::make_pair(SPACE, "SPACE"));
mapTargetStr_.insert(std::make_pair(TRAINSPACE, "SPACE"));//SPACE mapTargetStr_.insert(std::make_pair(TRAINSPACE, "SPACE"));
InitParam(); InitParam();
LogInfo << "FilterTrainStepOneEngine Init ok"; LogInfo << "FilterTrainStepOneEngine Init ok";
@ -118,7 +113,7 @@ void FilterTrainStepOneEngine::InitParam()
} }
iDirection_ = DIRECTION_UNKNOWN; iDirection_ = DIRECTION_UNKNOWN;
iNotChgCount_ = 0; iNotChgCount_ = 0;
while (!stackBackInfo_.empty()) while (!stackBackInfo_.empty())
{ {
stackBackInfo_.pop(); stackBackInfo_.pop();
@ -171,12 +166,11 @@ void FilterTrainStepOneEngine::AddBackInfo(std::shared_ptr<ProcessData> pProcess
} }
strAllClassType += mapTargetStr_[pPostData->vecPostSubData[i].iTargetType]; strAllClassType += mapTargetStr_[pPostData->vecPostSubData[i].iTargetType];
} }
LogDebug << "frameId:" << pProcessData->iFrameId << " addbackinfo strAllClassType:" << strAllClassType;
if (strAllClassType.empty()) if (strAllClassType.empty())
{ {
return; return;
} }
LogDebug << "frameId:" << pProcessData->iFrameId << " addbackinfo strAllClassType:" << strAllClassType;
TrainBackInfo trainBackInfo; TrainBackInfo trainBackInfo;
trainBackInfo.processData = pProcessData; trainBackInfo.processData = pProcessData;
@ -190,35 +184,8 @@ void FilterTrainStepOneEngine::AddBackInfo(std::shared_ptr<ProcessData> pProcess
else else
{ {
TrainBackInfo trainBackInfoTop = stackBackInfo_.top(); TrainBackInfo trainBackInfoTop = stackBackInfo_.top();
// 2024年3月27日修改前
// if (trainBackInfoTop.strAllClassType != trainBackInfo.strAllClassType)
// {
// stackBackInfo_.push(trainBackInfo);
// LogDebug << "frameId:" << pProcessData->iFrameId << " push strAllClassType:" << strAllClassType
// << " stacksize:" << stackBackInfo_.size();
// }
if (trainBackInfoTop.strAllClassType != trainBackInfo.strAllClassType) if (trainBackInfoTop.strAllClassType != trainBackInfo.strAllClassType)
{ {
if (iDirection_ == DIRECTION_RIGHT
&& trainBackInfo.strAllClassType == "SPACE"
&& (trainBackInfoTop.strAllClassType == "PROSPACE" || trainBackInfoTop.strAllClassType == "SPACEPRO"))
{
return;
}
if (iDirection_ == DIRECTION_RIGHT
&& trainBackInfo.strAllClassType == "SPACE"
&& (trainBackInfoTop.strAllClassType == "NUMSPACE" || trainBackInfoTop.strAllClassType == "SPACENUM"))
{
return;
}
if (iDirection_ == DIRECTION_LEFT
&& trainBackInfo.strAllClassType == "SPACE"
&& (trainBackInfoTop.strAllClassType == "NUMSPACE" || trainBackInfoTop.strAllClassType == "SPACENUM"))
{
return;
}
stackBackInfo_.push(trainBackInfo); stackBackInfo_.push(trainBackInfo);
LogDebug << "frameId:" << pProcessData->iFrameId << " push strAllClassType:" << strAllClassType LogDebug << "frameId:" << pProcessData->iFrameId << " push strAllClassType:" << strAllClassType
<< " stacksize:" << stackBackInfo_.size(); << " stacksize:" << stackBackInfo_.size();
@ -233,19 +200,16 @@ bool FilterTrainStepOneEngine::IsEndDealBackInfo(std::shared_ptr<ProcessData> pP
return true; return true;
} }
bool bPopFlag = false;
std::shared_ptr<PostData> pPostData = std::static_pointer_cast<PostData>(pProcessData->pVoidData);
if (pPostData->vecPostSubData.size() == 0) return false;
/* /*
处理倒车数据时，数据需设置为倒车，主要是保证这样的数据后面Engine不处理，防止切分车厢出错。 处理倒车数据时，数据需设置为倒车，主要是保证这样的数据后面Engine不处理，防止切分车厢出错。
类型不相等时，就pop，当pop后，还剩一个数据时，则表示已经回到了刚开始倒车的地方。（只剩一个数据的逻辑在上方） 类型不相等时，就pop，当pop后，还剩一个数据时，则表示已经回到了刚开始倒车的地方。
处理最后一个时，不能只判断下类型相同就弹出。需要控制下位置。(要么类型相同位置合适，要么类型不相同) 处理最后一个时，不能只判断下类型相同就弹出。需要控制下位置。(要么类型相同位置合适，要么类型不相同)
正向为向左行驶，则当前数据的位置尽量小于等于栈中最后一个元素的位置。 正向为向左行驶，则当前数据的位置尽量小于等于栈中最后一个元素的位置。
正向为向右行驶，则当前数据的位置尽量大于等于栈中最后一个元素的位置。 正向为向右行驶，则当前数据的位置尽量大于等于栈中最后一个元素的位置。
*/ */
std::shared_ptr<PostData> pPostData = std::static_pointer_cast<PostData>(pProcessData->pVoidData);
std::sort(pPostData->vecPostSubData.begin(), pPostData->vecPostSubData.end(), CompareX); std::sort(pPostData->vecPostSubData.begin(), pPostData->vecPostSubData.end(), CompareX);
std::string strAllClassType; std::string strAllClassType;
@ -262,73 +226,48 @@ bool FilterTrainStepOneEngine::IsEndDealBackInfo(std::shared_ptr<ProcessData> pP
return false; return false;
} }
TrainBackInfo trainBackInfoTop = stackBackInfo_.top();
bool bPopFlag = false;
if (trainBackInfoTop.strAllClassType != strAllClassType)
{
bPopFlag = true;
}
LogDebug << "frameId:" << pProcessData->iFrameId << " stacksize:" << stackBackInfo_.size()
<< " topClassType:" << trainBackInfoTop.strAllClassType << " dealbackinfo strAllClassType:" << strAllClassType
<< " bPopFlag:" << bPopFlag;
if(bPopFlag)
{
stackBackInfo_.pop();
bPopFlag = false;
}
if (stackBackInfo_.size() == 1) if (stackBackInfo_.size() == 1)
{ {
TrainBackInfo trainBackInfoLast = stackBackInfo_.top(); if (!bPopFlag)
std::shared_ptr<PostData> pPostDataBack = std::static_pointer_cast<PostData>(trainBackInfoLast.processData->pVoidData);
std::sort(pPostDataBack->vecPostSubData.begin(), pPostDataBack->vecPostSubData.end(), CompareX);
for (size_t i = 0; i < pPostDataBack->vecPostSubData.size(); i++)
{ {
int bFlag = -1; TrainBackInfo trainBackInfoLast = stackBackInfo_.top();
for (size_t j = 0; j < pPostData->vecPostSubData.size(); j++) std::shared_ptr<PostData> pPostDataBack = std::static_pointer_cast<PostData>(trainBackInfoLast.processData->pVoidData);
std::sort(pPostDataBack->vecPostSubData.begin(), pPostDataBack->vecPostSubData.end(), CompareX);
for (size_t i = 0; i < pPostDataBack->vecPostSubData.size(); i++)
{ {
if (pPostDataBack->vecPostSubData[i].iBigClassId == pPostData->vecPostSubData[j].iBigClassId) bool bFlag = (pPostDataBack->vecPostSubData[i].step1Location.fLTX <= pPostData->vecPostSubData[i].step1Location.fLTX);
LogDebug << "frameId:" << pProcessData->iFrameId << " stackFrameid:" << pPostDataBack->iFrameId << " bFlag:" << bFlag;
if ((iDirection_ == DIRECTION_LEFT && !bFlag) ||
(iDirection_ == DIRECTION_RIGHT && bFlag))
{ {
if (pPostData->vecPostSubData[j].step1Location.fLTX < 1 || pPostDataBack->vecPostSubData[i].step1Location.fLTX < 1) bPopFlag = true;
{ break;
LogDebug << "大框X坐标小于1，判定为异常大框。过滤！！";
break;
}
bFlag = (pPostDataBack->vecPostSubData[i].step1Location.fLTX <= pPostData->vecPostSubData[j].step1Location.fLTX) ? 1 : 0;
LogDebug << "帧:" << pProcessData->iFrameId << " 倒车前帧:" << pPostDataBack->iFrameId << " 恢复到原位:" << bFlag
<< " 当前框位置:" << pPostData->vecPostSubData[i].step1Location.fLTX
<< " 倒车前位置:" << pPostDataBack->vecPostSubData[i].step1Location.fLTX << "方向：" << iDirection_;
} }
} }
if (bPopFlag)
if ((iDirection_ == DIRECTION_LEFT && bFlag == 0) ||
(iDirection_ == DIRECTION_RIGHT && bFlag == 1))
{ {
bPopFlag = true; LogDebug << "frameId:" << pProcessData->iFrameId << " last one bPopFlag:" << bPopFlag;
break; stackBackInfo_.pop();
} }
} }
if (bPopFlag)
{
LogDebug << "frameId:" << pProcessData->iFrameId << " 恢复倒车前的位置:" << bPopFlag;
stackBackInfo_.pop();
}
} }
else
{
TrainBackInfo trainBackInfoTop_bak = stackBackInfo_.top();
stackBackInfo_.pop();
TrainBackInfo trainBackInfoTop = stackBackInfo_.top();
if (trainBackInfoTop.strAllClassType != strAllClassType)
{
stackBackInfo_.push(trainBackInfoTop_bak);
LogDebug << "帧:" << pProcessData->iFrameId << " 倒车信息:" << stackBackInfo_.size()
<< " 顶部倒车信息:" << trainBackInfoTop.strAllClassType << " 本次识别信息:" << strAllClassType;
}
else
{
// bPopFlag = true;
LogDebug << "帧:" << pProcessData->iFrameId << " 倒车信息:" << stackBackInfo_.size()
<< " 顶部倒车信息:" << trainBackInfoTop.strAllClassType << " 本次识别信息:" << strAllClassType
<< " 删除倒车信息:" << trainBackInfoTop_bak.strAllClassType;
}
// if(bPopFlag)
// {
// stackBackInfo_.pop();
// bPopFlag = false;
// }
}
return stackBackInfo_.empty() ? true : false; return stackBackInfo_.empty() ? true : false;
} }
@ -336,29 +275,31 @@ bool FilterTrainStepOneEngine::IsEndDealBackInfo(std::shared_ptr<ProcessData> pP
* 校验火车是否停止 * 校验火车是否停止
* inParam : std::shared_ptr<ProcessData> pProcessData :待处理数据 * inParam : std::shared_ptr<ProcessData> pProcessData :待处理数据
* outParam: N/A * outParam: N/A
* return : true:停止; false:非停止 1(正常行驶) 2(停车) 3(倒车) * return : true:停止; false:非停止 1(正常行驶) 2(停车) 3(倒车)
*/ */
int FilterTrainStepOneEngine::GetTrainStatus(std::shared_ptr<ProcessData> pProcessData) int FilterTrainStepOneEngine::GetTrainStatus(std::shared_ptr<ProcessData> pProcessData)
{ {
if (iDirection_ == DIRECTION_UNKNOWN) if (iDirection_ == DIRECTION_UNKNOWN)
{ {
LogDebug << " frameId:" << pProcessData->iFrameId << " 未判断出行车方向，暂定认为火车正常行驶中"; LogDebug << "sourceid:" << pProcessData->iDataSource << " frameId:" << pProcessData->iFrameId << " direction unknown trainStatus=1";
return TRAINSTATUS_RUN; return TRAINSTATUS_RUN;
} }
std::shared_ptr<PostData> pPostData = std::static_pointer_cast<PostData>(pProcessData->pVoidData); std::shared_ptr<PostData> pPostData = std::static_pointer_cast<PostData>(pProcessData->pVoidData);
pPostData->iFrameId = pProcessData->iFrameId; pPostData->iFrameId = pProcessData->iFrameId;
quePostData_.push(*pPostData.get());
// 1. 无框时，返回之前的列车状态 // 1. 无框时，返回之前的列车状态
if (pPostData->vecPostSubData.size() == 0) if (pPostData->vecPostSubData.size() == 0)
{ {
LogDebug << "sourceid:" << pProcessData->iDataSource << " frameId:" << pProcessData->iFrameId << " step1 no result trainStatus="<< iTrainStatus_;
quePostData_.pop();
return iTrainStatus_; return iTrainStatus_;
} }
quePostData_.push(*pPostData.get());
if (quePostData_.size() < 3) if (quePostData_.size() < 3)
{ {
LogDebug << "sourceid:" << pProcessData->iDataSource << " frameId:" << pProcessData->iFrameId << " size < 3 trainStatus=1";
return TRAINSTATUS_RUN; return TRAINSTATUS_RUN;
} }
@ -369,7 +310,7 @@ int FilterTrainStepOneEngine::GetTrainStatus(std::shared_ptr<ProcessData> pProce
{ {
quePostData_.pop(); quePostData_.pop();
} }
LogDebug << "frameId:" << pProcessData->iFrameId << " 判断运动状态队列 第一帧:" << postDataFront.iFrameId << " 队列size:" << quePostData_.size() << " iSizeTemp:" << iSizeTemp; LogDebug << "queue front frameId:" << postDataFront.iFrameId << " queuesize:" << quePostData_.size() << " iSizeTemp:" << iSizeTemp;
bool bSameFlag = false; bool bSameFlag = false;
int iDiffValue = iChkStopPX_; int iDiffValue = iChkStopPX_;
@ -385,7 +326,6 @@ int FilterTrainStepOneEngine::GetTrainStatus(std::shared_ptr<ProcessData> pProce
*/ */
if (postSubDataFront.iTargetType != postSubDataBack.iTargetType) if (postSubDataFront.iTargetType != postSubDataBack.iTargetType)
{ {
LogDebug << "判断前后帧识别的是否一致 上一个：" << postSubDataFront.iTargetType << " 当前：" << postSubDataBack.iTargetType;
continue; continue;
} }
@ -400,7 +340,7 @@ int FilterTrainStepOneEngine::GetTrainStatus(std::shared_ptr<ProcessData> pProce
//位置比较大于10个像素，则表示有移动。再判断时正向移动，还是倒车 //位置比较大于10个像素，则表示有移动。再判断时正向移动，还是倒车
LogDebug << "frameId:" << pProcessData->iFrameId << " " << iCenterBack << "-" << iCenterFront LogDebug << "frameId:" << pProcessData->iFrameId << " " << iCenterBack << "-" << iCenterFront
<< "=" << abs(iCenterBack - iCenterFront) << " 预期判定移动的差值为iDiffValue:" << iDiffValue; << "=" << abs(iCenterBack - iCenterFront) << " iDiffValue:" << iDiffValue;
if (abs(iCenterBack - iCenterFront) > iDiffValue) if (abs(iCenterBack - iCenterFront) > iDiffValue)
{ {
iNotChgCount_ = 0; iNotChgCount_ = 0;
@ -412,38 +352,32 @@ int FilterTrainStepOneEngine::GetTrainStatus(std::shared_ptr<ProcessData> pProce
if ((iCenterBack > iCenterFront && iDirection_ == DIRECTION_LEFT) || if ((iCenterBack > iCenterFront && iDirection_ == DIRECTION_LEFT) ||
(iCenterBack < iCenterFront && iDirection_ == DIRECTION_RIGHT)) (iCenterBack < iCenterFront && iDirection_ == DIRECTION_RIGHT))
{ {
if (this->iPartitionFrameNum_ < (pProcessData->iFrameId - postDataFront.iFrameId) LogDebug << "frameId:" << pProcessData->iFrameId << " back1";
&& this->iPlitFrameSpanPX_ < abs(iCenterBack - iCenterFront))
{
return TRAINSTATUS_RUN;
}
LogDebug << "frameId:" << pProcessData->iFrameId << " 检测到火车倒车";
return TRAINSTATUS_BACK; return TRAINSTATUS_BACK;
} }
else else
{ {
LogDebug << "frameId:" << pProcessData->iFrameId << " 正常行驶"; LogDebug << "frameId:" << pProcessData->iFrameId << " run";
return TRAINSTATUS_RUN; return TRAINSTATUS_RUN;
} }
} }
/* /*
小于10个像素表示可能停车，累计未变化次数。 小于10个像素表示可能停车，累计未变化次数。
累计变化次数超过10次，返回停车 累计变化次数超过10次，返回停车
累计变化次数未超过10次，返回之前行驶状态 累计变化次数未超过10次，返回之前行驶状态
*/ */
else else
{ {
iNotChgCount_++; iNotChgCount_++;
LogDebug << " frameId:" << pProcessData->iFrameId LogDebug << " frameId:" << pProcessData->iFrameId << " no chg iNotChgCount:" << iNotChgCount_;
<< " 大框移动范围小 判断停车计数:" << iNotChgCount_ << "/" << iChkStopCount_;
if (iNotChgCount_ > iChkStopCount_) if (iNotChgCount_ > iChkStopCount_)
{ {
LogDebug << "frameId:" << pProcessData->iFrameId << " 检测到火车停车"; LogDebug << "frameId:" << pProcessData->iFrameId << " stop";
return TRAINSTATUS_STOP; return TRAINSTATUS_STOP;
} }
else else
{ {
// LogDebug << "frameId:" << pProcessData->iFrameId << " iTrainStatus_:" << iTrainStatus_; LogDebug << "frameId:" << pProcessData->iFrameId << " iTrainStatus_:" << iTrainStatus_;
return iTrainStatus_; return iTrainStatus_;
} }
} }
@ -509,8 +443,8 @@ int FilterTrainStepOneEngine::GetTrainStatus(std::shared_ptr<ProcessData> pProce
} }
} }
// LogDebug << "frameId:" << pProcessData->iFrameId << " back2"; LogDebug << "frameId:" << pProcessData->iFrameId << " back2";
return iTrainStatus_; return TRAINSTATUS_BACK;
} }
} }
LogDebug << "frameId:" << pProcessData->iFrameId << " iNotChgCount_:" << iNotChgCount_ << " run run"; LogDebug << "frameId:" << pProcessData->iFrameId << " iNotChgCount_:" << iNotChgCount_ << " run run";
@ -557,7 +491,7 @@ void FilterTrainStepOneEngine::SetDirection(std::vector<Step1Location> &vecLocat
{ {
iDirection_ = DIRECTION_LEFT; iDirection_ = DIRECTION_LEFT;
} }
//行驶方向 右 //行驶方向 右
else if ((slBack.fLTX - slFront.fLTX) > 0) else if ((slBack.fLTX - slFront.fLTX) > 0)
{ {
iDirection_ = DIRECTION_RIGHT; iDirection_ = DIRECTION_RIGHT;
@ -789,8 +723,7 @@ void FilterTrainStepOneEngine::CalculateDirection(std::shared_ptr<ProcessData> p
} }
void FilterTrainStepOneEngine::sendComeTrain(const std::string strTrainDate, const std::string strTrainName, const int iDirection) { void FilterTrainStepOneEngine::sendComeTrain(const std::string strTrainDate, const std::string strTrainName, const int iDirection) {
std::string message = "{\"cometime\":\"" + strTrainDate + " " + strTrainName + "\",\"type\":\"1\",\"direction\":" + to_string(iDirection == iPushDirection_ ? 1:-1) + "}"; std::string message = "{\"cometime\":\"" + strTrainDate + " " + strTrainName + "\",\"type\":\"1\",\"direction\":\"" + to_string(iDirection) + "\"}";
LogWarn << message;
outputQueMap_[engineName_ + "_" + std::to_string(engineId_) + "_1"]->push(std::static_pointer_cast<void>(std::make_shared<std::string>(message))); outputQueMap_[engineName_ + "_" + std::to_string(engineId_) + "_1"]->push(std::static_pointer_cast<void>(std::make_shared<std::string>(message)));
} }
@ -897,31 +830,31 @@ void FilterTrainStepOneEngine::DealProcessDataPre(std::shared_ptr<ProcessData> p
{ {
if (iterHeadContinueCnt->second < 2 && it->iTargetType == HEAD) if (iterHeadContinueCnt->second < 2 && it->iTargetType == HEAD)
{ {
LogDebug << " frameId:" << iterProcessData->second->iFrameId << " Head 框因非连续识别而过滤"; LogError << "sourceid:" << iterProcessData->second->iDataSource << " frameId:" << iterProcessData->second->iFrameId << " Head wrong";
it = pPostDataPre->vecPostSubData.erase(it); it = pPostDataPre->vecPostSubData.erase(it);
continue; continue;
} }
if (iterProContinueCnt->second < 2 && it->iTargetType == PRO) if (iterProContinueCnt->second < 2 && it->iTargetType == PRO)
{ {
LogDebug << " frameId:" << iterProcessData->second->iFrameId << " PRO 框因非连续识别而过滤"; LogError << "sourceid:" << iterProcessData->second->iDataSource << " frameId:" << iterProcessData->second->iFrameId << " PRO wrong";
it = pPostDataPre->vecPostSubData.erase(it); it = pPostDataPre->vecPostSubData.erase(it);
continue; continue;
} }
if (iterNumContinueCnt->second < 2 && it->iTargetType == NUM) if (iterNumContinueCnt->second < 2 && it->iTargetType == NUM)
{ {
LogDebug << " frameId:" << iterProcessData->second->iFrameId << " NUM 框因非连续识别而过滤"; LogError << "sourceid:" << iterProcessData->second->iDataSource << " frameId:" << iterProcessData->second->iFrameId << " NUM wrong";
it = pPostDataPre->vecPostSubData.erase(it); it = pPostDataPre->vecPostSubData.erase(it);
continue; continue;
} }
if (iterSpaceContinueCnt->second < 2 && it->iTargetType == SPACE) if (iterSpaceContinueCnt->second < 2 && it->iTargetType == SPACE)
{ {
LogDebug << " frameId:" << iterProcessData->second->iFrameId << " SPACE 框因非连续识别而过滤"; LogError << "sourceid:" << iterProcessData->second->iDataSource << " frameId:" << iterProcessData->second->iFrameId << " SPACE wrong";
it = pPostDataPre->vecPostSubData.erase(it); it = pPostDataPre->vecPostSubData.erase(it);
continue; continue;
} }
if (iterTranSpaceContinueCnt->second < 2 && it->iTargetType == TRAINSPACE) if (iterTranSpaceContinueCnt->second < 2 && it->iTargetType == TRAINSPACE)
{ {
LogDebug << " frameId:" << iterProcessData->second->iFrameId << " TRAINSPACE 框因非连续识别而过滤"; LogError << "sourceid:" << iterProcessData->second->iDataSource << " frameId:" << iterProcessData->second->iFrameId << " TRAINSPACE wrong";
it = pPostDataPre->vecPostSubData.erase(it); it = pPostDataPre->vecPostSubData.erase(it);
continue; continue;
} }
@ -938,7 +871,6 @@ void FilterTrainStepOneEngine::DealProcessDataPre(std::shared_ptr<ProcessData> p
{ {
//CalculateDirection(iterProcessData->second); //CalculateDirection(iterProcessData->second);
CalculateDirectionNew(iterProcessData->second); CalculateDirectionNew(iterProcessData->second);
if (iDirection_ != DIRECTION_UNKNOWN) this->sendComeTrain(pProcessData->strTrainDate, pProcessData->strTrainName, iDirection_);
} }
if (iDirection_ != DIRECTION_UNKNOWN) if (iDirection_ != DIRECTION_UNKNOWN)
@ -969,7 +901,7 @@ void FilterTrainStepOneEngine::DealProcessDataPre(std::shared_ptr<ProcessData> p
{ {
//倒车 //倒车
AddBackInfo(iterProcessData->second); AddBackInfo(iterProcessData->second);
iTrainStatusTemp = TRAINSTATUS_STOP; iTrainStatusTemp = TRAINSTATUS_STOP;
} }
else if(iTrainStatus_ == TRAINSTATUS_RUN) else if(iTrainStatus_ == TRAINSTATUS_RUN)
{ {
@ -986,7 +918,7 @@ void FilterTrainStepOneEngine::DealProcessDataPre(std::shared_ptr<ProcessData> p
<< " 火车实时运行状态:" << iTrainStatus_ << "(0无车，1运行，2停车，3倒车) iTrainStatusTemp:" << iTrainStatusTemp; << " 火车实时运行状态:" << iTrainStatus_ << "(0无车，1运行，2停车，3倒车) iTrainStatusTemp:" << iTrainStatusTemp;
iterProcessData->second->iStatus = iTrainStatusTemp; iterProcessData->second->iStatus = iTrainStatusTemp;
// this->sendComeTrain(pProcessData->strTrainDate, pProcessData->strTrainName, iDirection_); this->sendComeTrain(pProcessData->strTrainDate, pProcessData->strTrainName, iDirection_);
//上一帧，push端口0 //上一帧，push端口0
PushData(strPort0_, iterProcessData->second); PushData(strPort0_, iterProcessData->second);

5
nvidia_ascend_engine/common_engine/FilterEngine/FilterTrainStepOneEngine.h
View File

@ -58,11 +58,6 @@ private:
int iChkStopPX_; int iChkStopPX_;
int iChkStopCount_; int iChkStopCount_;
int iDirection_; //方向 int iDirection_; //方向
int iPushDirection_; //需要识别的方向
int rightFirst_; // 向右行驶的在前大框类型
int leftFirst_; // 向左行驶的在前大框类型
int iPartitionFrameNum_; //满足跨车厢的帧间隔
int iPlitFrameSpanPX_; //相连帧 同种大框的跨度最大值
std::map<int, PostData> mapPostDataFrist_; //[key-数据源id, value-第一步识别信息] std::map<int, PostData> mapPostDataFrist_; //[key-数据源id, value-第一步识别信息]
std::map<int, std::map<int, std::vector<Step1Location>>> mapMapStep1Info_; //[key-数据源id, value-[key-识别目标, value-识别框集合]] std::map<int, std::map<int, std::vector<Step1Location>>> mapMapStep1Info_; //[key-数据源id, value-[key-识别目标, value-识别框集合]]

16
nvidia_ascend_engine/common_engine/SaveEngine/SaveCsvEngine.cpp
View File

@ -83,10 +83,7 @@ bool SaveCsvEngine::SaveMergerCsv(std::shared_ptr<Train> pTrain)
<< "inspection" << ',' << "inspection" << ','
<< "inspectionImg" << ',' << "inspectionImg" << ','
<< "containerImg_1" << ',' << "containerImg_1" << ','
<< "containerImg_2" << ',' << "containerImg_2" << std::endl;
<< "startTime" << ','
<< "endTime"
<< std::endl;
} }
std::string strTime = pTrain->strTrainName; std::string strTime = pTrain->strTrainName;
@ -150,10 +147,7 @@ bool SaveCsvEngine::SaveMergerCsv(std::shared_ptr<Train> pTrain)
<< pTrain->chkDate.strChkDate1DeadLine << ',' << pTrain->chkDate.strChkDate1DeadLine << ','
<< szChkDateImgPath << ',' << szChkDateImgPath << ','
<< szContainer1ImgPath << ',' << szContainer1ImgPath << ','
<< szContainer2ImgPath << ',' << szContainer2ImgPath << std::endl;
<< MyUtils::getins()->Stamp2Time(pTrain->i64StartTimeStamp, true) << ','
<< MyUtils::getins()->Stamp2Time(pTrain->i64EndTimeStamp, true)
<< std::endl;
outFile.close(); outFile.close();
} }
@ -433,18 +427,18 @@ bool SaveCsvEngine::SaveContainerCsv(std::shared_ptr<TrainContainer> pTrainConta
catch (const std::exception &) catch (const std::exception &)
{ {
LogError << "strCsvPath:" << strCsvPath << " container savecsv fail!"; LogError << "strCsvPath:" << strCsvPath << " container savecsv fail!";
continue; continue;
} }
} }
return true; return true;
} }
APP_ERROR SaveCsvEngine::Process() APP_ERROR SaveCsvEngine::Process()
{ {
int iRet = APP_ERR_OK; int iRet = APP_ERR_OK;
while (!isStop_) while (!isStop_)
{ {
bool bPopFlag = false; bool bPopFlag = false;
//pop端口0 车厢信息 //pop端口0 车厢信息
std::shared_ptr<void> pVoidData0 = nullptr; std::shared_ptr<void> pVoidData0 = nullptr;

2
nvidia_ascend_engine/common_engine/SaveEngine/SaveImgEngine.cpp
View File

@ -160,7 +160,7 @@ APP_ERROR SaveImgEngine::Process()
jvFrameInfo["rate"] = iRate; jvFrameInfo["rate"] = iRate;
jvFrameInfo["isEnd"] = pSaveImgData->bIsEnd; jvFrameInfo["isEnd"] = pSaveImgData->bIsEnd;
MyUtils::getins()->WriteJsonInfo(jvFrameInfo, strTxtFilePath); MyUtils::getins()->WriteJsonInfo(jvFrameInfo, strTxtFilePath);
// LogDebug << "engineId:" << engineId_ << " save success txt:" << strTxtFilePath; LogDebug << "engineId:" << engineId_ << " save success txt:" << strTxtFilePath;
} }
} }
return APP_ERR_OK; return APP_ERR_OK;

38
nvidia_ascend_engine/common_engine/SaveEngine/SaveStepOneResultEngine.cpp
View File

@ -119,10 +119,10 @@ void SaveStepOneResultEngine::DealCenterSpace(std::vector<PartionInfo> &vecParat
{ {
return; return;
} }
LogDebug << "积累的车厢切分信息数:" << iVecSize << " 帧:" << pProcessData->iFrameId LogDebug << "size:" << iVecSize << " frameId:" << pProcessData->iFrameId
<< " 第一个车厢切分信息帧:" << vecParationInfo.at(0).modelSpaceFrame << " vecParationInfo[0].frameId:" << vecParationInfo.at(0).modelSpaceFrame
<< " 最后一个车厢切分信息帧:" << vecParationInfo.at(iVecSize - 1).modelSpaceFrame << " vecParationInfo[size-1].frameId:" << vecParationInfo.at(iVecSize - 1).modelSpaceFrame
<< " 最后一个车厢切分信息是否为结束:" << vecParationInfo.at(iVecSize - 1).bIsEnd; << " isEnd:" << vecParationInfo.at(iVecSize - 1).bIsEnd;
/* /*
因停车后再行驶未能及时判断出为行驶状态，导致更新间隔信息，出现漏切分车厢(具体原因分析见正通2023-02-28的问题分析记录) 因停车后再行驶未能及时判断出为行驶状态，导致更新间隔信息，出现漏切分车厢(具体原因分析见正通2023-02-28的问题分析记录)
@ -134,9 +134,9 @@ void SaveStepOneResultEngine::DealCenterSpace(std::vector<PartionInfo> &vecParat
int iCenterXPre = vecParationInfo[i - 1].fLTX + (vecParationInfo[i - 1].fRBX - vecParationInfo[i - 1].fLTX) / 2; int iCenterXPre = vecParationInfo[i - 1].fLTX + (vecParationInfo[i - 1].fRBX - vecParationInfo[i - 1].fLTX) / 2;
int iCenterX = vecParationInfo[i].fLTX + (vecParationInfo[i].fRBX - vecParationInfo[i].fLTX) / 2; int iCenterX = vecParationInfo[i].fLTX + (vecParationInfo[i].fRBX - vecParationInfo[i].fLTX) / 2;
bool bIntervalFlag = ((int)(vecParationInfo[i].modelSpaceFrame - vecParationInfo[i - 1].modelSpaceFrame)) > iSplitSpan_; bool bIntervalFlag = ((int)(vecParationInfo[i].modelSpaceFrame - vecParationInfo[i - 1].modelSpaceFrame)) > iSplitSpan_;
LogDebug << "上一帧ID:" << vecParationInfo[i - 1].modelSpaceFrame << " 上一帧间隔X轴中线:" << iCenterXPre LogDebug << "frameidPre:" << vecParationInfo[i - 1].modelSpaceFrame << " iCenterXPre:" << iCenterXPre
<< " 本帧ID:" << vecParationInfo[i].modelSpaceFrame << " 本帧间隔X轴中线:" << iCenterX << " frameid:" << vecParationInfo[i].modelSpaceFrame << " iCenterX:" << iCenterX
<< " 满足帧间隔:" << bIntervalFlag << " i:" << i; << " bIntervalFlag:" << bIntervalFlag << " i:" << i;
if (iDirection_ == DIRECTION_LEFT && (iCenterXPre < iCenterX - iSplitSpanPX_) && bIntervalFlag) if (iDirection_ == DIRECTION_LEFT && (iCenterXPre < iCenterX - iSplitSpanPX_) && bIntervalFlag)
{ {
vecSpacePos.push_back(i - 1); vecSpacePos.push_back(i - 1);
@ -190,8 +190,6 @@ void SaveStepOneResultEngine::DealCenterSpace(std::vector<PartionInfo> &vecParat
pPartionInfo->startframe = dataSourceConfig_.iSkipInterval; pPartionInfo->startframe = dataSourceConfig_.iSkipInterval;
} }
pPartionInfo->nStatus = ((pProcessData->iStatus == TRAINSTATUS_STOP) ? TRAIN_PAUSE : iDirection_); pPartionInfo->nStatus = ((pProcessData->iStatus == TRAINSTATUS_STOP) ? TRAIN_PAUSE : iDirection_);
LogWarn << "--------- 向Paration 发送数据 --------";
outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pPartionInfo)); outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pPartionInfo));
iPushSpaceFrameId_ = pPartionInfo->modelSpaceFrame; iPushSpaceFrameId_ = pPartionInfo->modelSpaceFrame;
@ -244,18 +242,14 @@ void SaveStepOneResultEngine::DealTrainSpaceInfo(std::shared_ptr<ProcessData> pP
{ {
iDirection_ = jvDirectionInfo["direction"].asInt(); iDirection_ = jvDirectionInfo["direction"].asInt();
} }
else
{
LogWarn << "暂未检测出行车方向";
}
} }
bool bIntervalFlag = ((int)(pProcessData->iFrameId - parationInfoLast_.modelSpaceFrame)) > iSplitSpan_; bool bIntervalFlag = ((int)(pProcessData->iFrameId - parationInfoLast_.modelSpaceFrame)) > iSplitSpan_;
int iCenterCur = jvStep1Space[0]["ltx"].asFloat() + (jvStep1Space[0]["rbx"].asFloat() - jvStep1Space[0]["ltx"].asFloat()) / 2; int iCenterCur = jvStep1Space[0]["ltx"].asFloat() + (jvStep1Space[0]["rbx"].asFloat() - jvStep1Space[0]["ltx"].asFloat()) / 2;
int iCenterLast = parationInfoLast_.fLTX + (parationInfoLast_.fRBX - parationInfoLast_.fLTX) / 2; int iCenterLast = parationInfoLast_.fLTX + (parationInfoLast_.fRBX - parationInfoLast_.fLTX) / 2;
LogDebug << "当前帧:" << pProcessData->iFrameId << " 间隔框中心线:" << iCenterCur LogDebug << "frameid:" << pProcessData->iFrameId << " centerCur:" << iCenterCur
<< " 上一帧:" << parationInfoLast_.modelSpaceFrame << " 间隔框中心线:" << iCenterLast << " lastFrameid:" << parationInfoLast_.modelSpaceFrame << " centerLast:" << iCenterLast
<< " 行车方向:" << iDirection_ << " 是否满足切分帧数:" << bIntervalFlag << " bDealCenterFlag_:" << bDealCenterFlag_; << " iDirection_:" << iDirection_ << " bIntervalFlag:" << bIntervalFlag << " bDealCenterFlag_:" << bDealCenterFlag_;
if (iDirection_ == DIRECTION_UNKNOWN || iCenterLast == 0) if (iDirection_ == DIRECTION_UNKNOWN || iCenterLast == 0)
{ {
@ -301,8 +295,8 @@ void SaveStepOneResultEngine::DealTrainSpaceInfo(std::shared_ptr<ProcessData> pP
if (!(bDealCenterFlag_ && !bIntervalFlag && (iCenterCur < (pProcessData->iWidth / 3 + 30)))) if (!(bDealCenterFlag_ && !bIntervalFlag && (iCenterCur < (pProcessData->iWidth / 3 + 30))))
{ {
vecParationInfo_.push_back(parationInfo); vecParationInfo_.push_back(parationInfo);
} }
} }
} }
else if (iDirection_ == DIRECTION_RIGHT) else if (iDirection_ == DIRECTION_RIGHT)
{ {
@ -424,7 +418,7 @@ void SaveStepOneResultEngine::SplitTrainByNumPro(std::shared_ptr<PartionInfo> &p
pPartionInfoNew->i64StartTimeStamp = i64TimeStampFirst_; pPartionInfoNew->i64StartTimeStamp = i64TimeStampFirst_;
pPartionInfoNew->startframe = dataSourceConfig_.iSkipInterval; pPartionInfoNew->startframe = dataSourceConfig_.iSkipInterval;
} }
// pPartionInfoNew->nStatus = ((pProcessData->iStatus == TRAINSTATUS_STOP) ? TRAIN_PAUSE : iDirection_); pPartionInfoNew->nStatus = ((pProcessData->iStatus == TRAINSTATUS_STOP) ? TRAIN_PAUSE : iDirection_);
//构造一个间隔信息写入到切分帧中 //构造一个间隔信息写入到切分帧中
char szCameraNo[5] = {0}; char szCameraNo[5] = {0};
@ -443,7 +437,6 @@ void SaveStepOneResultEngine::SplitTrainByNumPro(std::shared_ptr<PartionInfo> &p
jvFrameInfo["step1Space"].append(jvOneSpace); jvFrameInfo["step1Space"].append(jvOneSpace);
MyUtils::getins()->WriteJsonInfo(jvFrameInfo, strFilePath); MyUtils::getins()->WriteJsonInfo(jvFrameInfo, strFilePath);
LogWarn << "--------- 向Paration 发送数据 --------";
outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pPartionInfoNew)); outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pPartionInfoNew));
iPushSpaceFrameId_ = pPartionInfoNew->modelSpaceFrame; iPushSpaceFrameId_ = pPartionInfoNew->modelSpaceFrame;
@ -550,7 +543,7 @@ APP_ERROR SaveStepOneResultEngine::Process()
{ {
//车头没有属性，因此车头号也加入到属性中。保证向右行驶属性在前时最后2节的切分。 //车头没有属性，因此车头号也加入到属性中。保证向右行驶属性在前时最后2节的切分。
//车头只加入一次，防止一个车头2个车头号的场景。但有两个车头且没识别车头间隔则无法处理。 //车头只加入一次，防止一个车头2个车头号的场景。但有两个车头且没识别车头间隔则无法处理。
if (!bHaveHeadFlag_) if (!bHaveHeadFlag_)
{ {
bool bIntervalFlag = ((int)(pProcessData->iFrameId - headInfo_.iFrameId) > iSplitSpan_ && headInfo_.iFrameId != 0); bool bIntervalFlag = ((int)(pProcessData->iFrameId - headInfo_.iFrameId) > iSplitSpan_ && headInfo_.iFrameId != 0);
@ -585,7 +578,7 @@ APP_ERROR SaveStepOneResultEngine::Process()
} }
else if (postSubData.iTargetType == CONTAINER) else if (postSubData.iTargetType == CONTAINER)
{ {
jvStep1Container.append(jvInfo); jvStep1Container.append(jvInfo);
} }
else if (postSubData.iTargetType == SPACE) else if (postSubData.iTargetType == SPACE)
{ {
@ -688,7 +681,6 @@ APP_ERROR SaveStepOneResultEngine::Process()
//最后一节和倒数第二节之间的间隔未能识别时，此时也需要通过车号属性切分下。 //最后一节和倒数第二节之间的间隔未能识别时，此时也需要通过车号属性切分下。
SplitTrainByNumPro(pPartionInfo, pProcessData); SplitTrainByNumPro(pPartionInfo, pProcessData);
LogWarn << "--------- 向Paration 发送数据 --------";
outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pPartionInfo)); outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pPartionInfo));
iPushSpaceFrameId_ = pPartionInfo->modelSpaceFrame; iPushSpaceFrameId_ = pPartionInfo->modelSpaceFrame;

5
nvidia_ascend_engine/common_engine/SelectBestEngine/SelectBestEngine.cpp
View File

@ -212,11 +212,6 @@ std::string SelectBestEngine::GetBest(std::vector<TransInfo> &vecAllTransInfo, T
{ {
vecAllTransInfo = vecTransInfoTemp; vecAllTransInfo = vecTransInfoTemp;
} }
else
{
// 此处因车厢太脏。识别效果很差，难以与RFID识别结果融合，所以增加eles
return strValue;
}
//获取最优长度 //获取最优长度
int iBestLen = GetBestLength(vecAllTransInfo, iMaxLen); int iBestLen = GetBestLength(vecAllTransInfo, iMaxLen);

208
nvidia_ascend_engine/common_engine/TrainAnaEngine/TrainParationMgr.cpp
View File

@ -149,6 +149,7 @@ APP_ERROR TrainParationMgr::Process()
int nSize = lstPartInfo.size(); int nSize = lstPartInfo.size();
int nPartionIndex = nSize - 1; int nPartionIndex = nSize - 1;
int nPrePartionIndex = nPartionIndex;
//当然车厢通过的数量 //当然车厢通过的数量
if (nSize == 0) { if (nSize == 0) {
@ -165,30 +166,35 @@ APP_ERROR TrainParationMgr::Process()
lstPartInfo.push_back(stTempInfo); lstPartInfo.push_back(stTempInfo);
//lstPartInfo.push_back(stTempInfo); //lstPartInfo.push_back(stTempInfo);
nPartionIndex++; nPartionIndex++;
} }
lstPartInfo[nPartionIndex].i64EndTimeStamp = pPartionInfo->i64EndTimeStamp; {
lstPartInfo[nPartionIndex].endframe = pPartionInfo->modelSpaceFrame; lstPartInfo[nPartionIndex].i64EndTimeStamp = pPartionInfo->i64EndTimeStamp;
// 根据开始帧时间戳和结束帧时间错 计算当节车厢的行车速度 lstPartInfo[nPartionIndex].endframe = pPartionInfo->modelSpaceFrame;
// 根据时间戳计算时间差 // 根据开始帧时间戳和结束帧时间错 计算当节车厢的行车速度
// LogInfo << "TrainAnaEngine checkPartion bPartion == true lstPartInfo[nPrePartionIndex].ftime：" << abs(lstPartInfo[nPrePartionIndex].i64EndTimeStamp - lstPartInfo[nPrePartionIndex].i64StartTimeStamp);
// 根据时间戳计算时间差
float nTimePassed = (abs(lstPartInfo[nPartionIndex].i64EndTimeStamp - lstPartInfo[nPartionIndex].i64StartTimeStamp)) * 1.0;
//防止停车导致速度过小 float nTimePassed = (abs(lstPartInfo[nPartionIndex].i64EndTimeStamp - lstPartInfo[nPartionIndex].i64StartTimeStamp)) * 1.0;
if(pPartionInfo->nStatus != TRAIN_PAUSE && nTimePassed <= 50000) { //防止停车导致速度过小
lstPartInfo[nPartionIndex].fspeed = (TRAIN_WIDTH * 1000.0) /nTimePassed; if(pPartionInfo->nStatus != TRAIN_PAUSE && nTimePassed <= 50000) {
} else { lstPartInfo[nPartionIndex].fspeed = (TRAIN_WIDTH * 1000.0) /nTimePassed;
if (nPartionIndex >= 1){
lstPartInfo[nPartionIndex].fspeed = lstPartInfo[nPartionIndex - 1].fspeed / 3;
} else { } else {
lstPartInfo[nPartionIndex].fspeed = TRAIN_DEFAULT_SPEED / 10; if (nPartionIndex >= 1){
lstPartInfo[nPartionIndex].fspeed = lstPartInfo[nPartionIndex - 1].fspeed / 3;
} else {
lstPartInfo[nPartionIndex].fspeed = TRAIN_DEFAULT_SPEED / 10;
}
} }
//
//nSamePartionIgnoreCount = (nTimePassed / (3 * 5000)) * nFrameRate;
// 结束帧为当前帧再往后 (除以2的原因：中间为车钩，车钩后的车体宽度为整个镜头的宽度除以2)
//lstPartInfo[nPrePartionIndex].endframe = pPartionInfo->modelSpaceFrame;
//LogInfo << "TrainAnaEngine checkPartion bPartion == true lstPartInfo[nPrePartionIndex].endframe" << lstPartInfo[nPrePartionIndex].endframe;
lstPartInfo[nPartionIndex].bmodelconfirmed = true;
} }
//
//nSamePartionIgnoreCount = (nTimePassed / (3 * 5000)) * nFrameRate;
// 结束帧为当前帧再往后 (除以2的原因：中间为车钩，车钩后的车体宽度为整个镜头的宽度除以2)
lstPartInfo[nPartionIndex].bmodelconfirmed = true;
/// write json info to file /// write json info to file
//先读取文本内容，追加新的信息后再写入 //先读取文本内容，追加新的信息后再写入
@ -196,57 +202,133 @@ APP_ERROR TrainParationMgr::Process()
Json::Value jvPartionInfo; Json::Value jvPartionInfo;
//JSON保存路径 //JSON保存路径
std::string strFilePath; std::string strFilePath;
bool brightcome = false;
int nrightoffset = 0;
if (pPartionInfo->nStatus == 1) {
brightcome = true;
// nrightoffset = -1;
}
//检测到车厢划分信息 //检测到车厢划分信息
strFilePath = strResultPath_ + pPartionInfo->strTrainDate + "/" + pPartionInfo->strTrainName + "/" {
+ std::to_string(nPartionIndex + 1) + ".txt";
// if (nPartionIndex == 0) {
// lstPartInfo[nPartionIndex].endframe = lstPartInfo[nPartionIndex].endframe - nrightoffset * (lstPartInfo[nPartionIndex].fLTX - METHOD_BASE_WIDTH) / 10;
// } else {
// lstPartInfo[nPartionIndex].endframe = lstPartInfo[nPartionIndex].endframe - nrightoffset * getCouplerOffsetPix(lstPartInfo[nPartionIndex].fspeed, lstPartInfo[nPartionIndex].endframe);
// }
//lstPartInfo[nPartionIndex].endframe = lstPartInfo[nPartionIndex].endframe + getOffsetFrame(lstPartInfo[nPartionIndex].fspeed, (TRAIN_IN_CAMERA_WIDTH / 2), nFrameRate);
strFilePath = strResultPath_ + pPartionInfo->strTrainDate + "/" + pPartionInfo->strTrainName + "/"
+ std::to_string(nPartionIndex + 1) + ".txt";
LogInfo << "TrainAnaEngine Process lstPartInfo[nPartionIndex].startframe：" << lstPartInfo[nPartionIndex].startframe ; // 首部车钩的偏移位置 (单位帧)
LogInfo << "TrainAnaEngine Process lstPartInfo[nPartionIndex].endframe：" << lstPartInfo[nPartionIndex].endframe; int headpos = 0;
// 尾部车钩的偏移位置 (单位帧)
int tailpos = (0 - nTailPixOffset);
PartionInfo stTempInfo; //if (nPartionIndex == 0)
// 开始记录新的一节车厢信息(从索引变成序号+1 ，新增一节车厢信息+1) {
stTempInfo.nindex = nPartionIndex + 2; headpos = METHOD_BASE_WIDTH / 2;
// 上一节车厢的结束帧 - (偏移帧 = (镜头内的车体宽度/ (速度) -> 通过时间) * 帧/秒 ) 作为下一节车厢的开始帧 tailpos = tailpos + headpos;
int ntempOffsetFrame = lstPartInfo[nPartionIndex].endframe; }
stTempInfo.startframe = ntempOffsetFrame; // 是否位右侧来车
stTempInfo.i64StartTimeStamp = pPartionInfo->i64EndTimeStamp;
// 初始化下一节的结束帧 if (brightcome == true)
//stTempInfo.endframe = 0; {
//brightcome = true;
// 右侧来车 首部车钩从画面最右侧开始
headpos = METHOD_BASE_WIDTH / 2;
// 右侧来车 尾部车钩从画面最右侧+车厢宽的像素值
tailpos = headpos + nTailPixOffset;
/*
if (nPartionIndex == 0)
{
headpos = METHOD_BASE_WIDTH / 2;
tailpos = tailpos - headpos;
}
*/
}
LogInfo << "TrainAnaEngine Process lstPartInfo[nPartionIndex].startframe：" << lstPartInfo[nPartionIndex].startframe ;
LogInfo << "TrainAnaEngine Process lstPartInfo[nPartionIndex].endframe：" << lstPartInfo[nPartionIndex].endframe;
//从当节车厢的开始帧到结束帧计算首部车钩和尾部车钩的偏移值
// for (int nplayframe = lstPartInfo[nPartionIndex].startframe; nplayframe <= lstPartInfo[nPartionIndex].endframe; nplayframe++)
// {
// Json::Value jvposInfo;
// // 当前车厢的第几几帧
// int noffsetindex = (nplayframe - lstPartInfo[nPartionIndex].startframe);
// // 根据车速计算车钩位置量(单位 像素)
// int noffsetpos = getCouplerOffsetPosition(lstPartInfo[nPartionIndex].fspeed, noffsetindex);
// // 初始化首部车钩偏移量(单位 像素)
// jvposInfo["headpos"] = -1;
// // 初始化尾部车钩偏移量(单位 像素)
// jvposInfo["tailpos"] = -1;
// if (brightcome == false) {
// // 左侧来车
// // 首部车钩和尾部车钩 每帧加 车钩偏移值
// jvposInfo["headpos"] = (headpos + noffsetpos);
// jvposInfo["tailpos"] = (tailpos + noffsetpos);
// } else {
// // 右侧来车
// // 首部车钩和尾部车钩 每帧减 车钩偏移值
// jvposInfo["headpos"] = (headpos - noffsetpos);
// jvposInfo["tailpos"] = (tailpos - noffsetpos);
// }
// //LogInfo << "TrainAnaEngine Process jvposInfo[headpos]" << jvposInfo["headpos"];
// // LogInfo << "TrainAnaEngine Process jvposInfo[tailpos]:" << jvposInfo["tailpos"];
// //LogInfo << "TrainAnaEngine Process jvPartionListInfo.append";
// jvPartionInfo[std::to_string(nplayframe)] = jvposInfo;
// }
PartionInfo stTempInfo;
// 开始记录新的一节车厢信息(从索引变成序号+1 ，新增一节车厢信息+1)
stTempInfo.nindex = nPartionIndex + 2;
// 上一节车厢的结束帧 - (偏移帧 = (镜头内的车体宽度/ (速度) -> 通过时间) * 帧/秒 ) 作为下一节车厢的开始帧
int ntempOffsetFrame = lstPartInfo[nPartionIndex].endframe;
//
//- (int)(((TRAIN_IN_CAMERA_WIDTH / 2) / lstPartInfo[nPartionIndex].fspeed) * nFrameRate);
//LogInfo << "TrainAnaEngine Process ntempOffsetFrame:" << ntempOffsetFrame;
stTempInfo.startframe = ntempOffsetFrame;
stTempInfo.i64StartTimeStamp = pPartionInfo->i64EndTimeStamp;
// 初始化下一节的结束帧
//stTempInfo.endframe = 0;
lstPartInfo.push_back(stTempInfo); lstPartInfo.push_back(stTempInfo);
// 记录过车日期 // 记录过车日期
jvPartionInfo["trainDate"] = pPartionInfo->strTrainDate; jvPartionInfo["trainDate"] = pPartionInfo->strTrainDate;
// 记录过车时间 // 记录过车时间
jvPartionInfo["trainName"] = pPartionInfo->strTrainName; jvPartionInfo["trainName"] = pPartionInfo->strTrainName;
// 记录车厢节数 (索引从0开始 所以这里+1) // 记录车厢节数 (索引从0开始 所以这里+1)
jvPartionInfo["trainNo"] = nPartionIndex + 1; jvPartionInfo["trainNo"] = nPartionIndex + 1;
// 记录行车开始帧 // 记录行车开始帧
jvPartionInfo["startFrameId"] = lstPartInfo[nPartionIndex].startframe; jvPartionInfo["startFrameId"] = lstPartInfo[nPartionIndex].startframe;
jvPartionInfo["startTimeStamp"] = lstPartInfo[nPartionIndex].i64StartTimeStamp; jvPartionInfo["startTimeStamp"] = lstPartInfo[nPartionIndex].i64StartTimeStamp;
// 记录行车结束帧 // 记录行车结束帧
jvPartionInfo["endFrameId"] = lstPartInfo[nPartionIndex].endframe; jvPartionInfo["endFrameId"] = lstPartInfo[nPartionIndex].endframe;
jvPartionInfo["endTimeStamp"] = lstPartInfo[nPartionIndex].i64EndTimeStamp; jvPartionInfo["endTimeStamp"] = lstPartInfo[nPartionIndex].i64EndTimeStamp;
// 记录车厢是否完全通过 // 记录车厢是否完全通过
jvPartionInfo["isEnd"] = pPartionInfo->bIsEnd; jvPartionInfo["isEnd"] = pPartionInfo->bIsEnd;
//是否是间隔模型切分的车厢 //是否是间隔模型切分的车厢
jvPartionInfo["modelconfirmed"] = pPartionInfo->bmodelconfirmed; jvPartionInfo["modelconfirmed"] = pPartionInfo->bmodelconfirmed;
// 记录当前车厢的信息到JSON文件 // 记录当前车厢的信息到JSON文件
MyUtils::getins()->WriteJsonInfo(jvPartionInfo, strFilePath); MyUtils::getins()->WriteJsonInfo(jvPartionInfo, strFilePath);
std::shared_ptr<TrainRange> pTrainRange = std::make_shared<TrainRange>(); std::shared_ptr<TrainRange> pTrainRange = std::make_shared<TrainRange>();
pTrainRange->strTrainDate = jvPartionInfo["trainDate"].asString(); pTrainRange->strTrainDate = jvPartionInfo["trainDate"].asString();
pTrainRange->strTrainName = jvPartionInfo["trainName"].asString(); pTrainRange->strTrainName = jvPartionInfo["trainName"].asString();
pTrainRange->iTrainIndex = jvPartionInfo["trainNo"].asInt(); pTrainRange->iTrainIndex = jvPartionInfo["trainNo"].asInt();
pTrainRange->iStartFrameId = jvPartionInfo["startFrameId"].asInt(); pTrainRange->iStartFrameId = jvPartionInfo["startFrameId"].asInt();
pTrainRange->i64StartTimeStamp = jvPartionInfo["startTimeStamp"].asInt64(); pTrainRange->i64StartTimeStamp = jvPartionInfo["startTimeStamp"].asInt64();
pTrainRange->iEndFrameId = jvPartionInfo["endFrameId"].asInt(); pTrainRange->iEndFrameId = jvPartionInfo["endFrameId"].asInt();
pTrainRange->i64EndTimeStamp = jvPartionInfo["endTimeStamp"].asInt64(); pTrainRange->i64EndTimeStamp = jvPartionInfo["endTimeStamp"].asInt64();
pTrainRange->bIsEnd = jvPartionInfo["isEnd"].asBool(); pTrainRange->bIsEnd = jvPartionInfo["isEnd"].asBool();
pTrainRange->bmodelconfirmed = jvPartionInfo["modelconfirmed"].asBool(); pTrainRange->bmodelconfirmed = jvPartionInfo["modelconfirmed"].asBool();
iRet = outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pTrainRange)); iRet = outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pTrainRange));
}
if (pPartionInfo->bIsEnd) { if (pPartionInfo->bIsEnd) {
lstPartInfo.clear(); lstPartInfo.clear();

6
nvidia_ascend_engine/common_engine/TransEngine/TransTrainEngine.cpp
View File

@ -101,7 +101,7 @@ void TransTrainEngine::InitParam()
*/ */
bool TransTrainEngine::AuthTransNum(int classId, const std::string &trainNum) bool TransTrainEngine::AuthTransNum(int classId, const std::string &trainNum)
{ {
// LogInfo << "classId:" << classId << " trainNum:" << trainNum; LogInfo << "classId:" << classId << " trainNum:" << trainNum;
switch (classId) switch (classId)
{ {
case TRAIN_HEAD: // 车头上的编号 case TRAIN_HEAD: // 车头上的编号
@ -774,8 +774,8 @@ APP_ERROR TransTrainEngine::Process()
{ {
strTemp += vecClassNames_.at(it->second.at(j).iClassId); strTemp += vecClassNames_.at(it->second.at(j).iClassId);
} }
// LogDebug << "step2 char sourceid:" << pProcessData->iDataSource << " frameid:" << pProcessData->iFrameId LogDebug << "step2 char sourceid:" << pProcessData->iDataSource << " frameid:" << pProcessData->iFrameId
// << " bigclassId:" << postSubData.iBigClassId << " line:" << it->first << "," << strTemp; << " bigclassId:" << postSubData.iBigClassId << " line:" << it->first << "," << strTemp;
} }
TransSubData transSubData; TransSubData transSubData;

146
nvidia_ascend_engine/nvidia_engine/DataSourceEngine/TestImgEngine.cpp Normal file
View File

@ -0,0 +1,146 @@
#include "TestImgEngine.h"
#include <iostream>
#include <algorithm>
#include <string>
#include <stdio.h>
#include <stdarg.h>
#include <sys/time.h>
#include <string.h>
#include <vector>
#include <memory>
using namespace std;
using namespace ai_matrix;
TestImgEngine::TestImgEngine() {}
TestImgEngine::~TestImgEngine() {}
APP_ERROR TestImgEngine::Init()
{
strPort0_ = engineName_ + "_" + std::to_string(engineId_) + "_0";
dataSourceConfig_ = MyYaml::GetIns()->GetDataSourceConfigById(engineId_); //获取摄像机参数
width_ = IMAGE_WIDTH, height_ = IMAGE_HEIGHT;
LogInfo << "engineId_:" << engineId_ << " TestImgEngine Init ok";
return APP_ERR_OK;
}
APP_ERROR TestImgEngine::DeInit()
{
LogInfo << "engineId_:" << engineId_ << " TestImgEngine DeInit ok";
return APP_ERR_OK;
}
//测试jpeg解码时打开,并修改相应的yaml配置引擎间通信
#if 0
APP_ERROR TestImgEngine::Process()
{
int iRet = APP_ERR_OK;
uint64_t u64count_num = 0;
while (!isStop_)
{
// std::cout<<"Enter Read Image Thread "<<++u64count_num<<" Times!"<<std::endl;
// std::cout<<"Read Image Thread ID: "<<std::this_thread::get_id()<<std::endl;
//读取图像
std::string jpeg_img_file_name = MyYaml::GetIns()->GetStringValue("jpeg_image_file_name");
//从本地文件读取jpg图像并构造jpeg数据
void* pJPEGBuffer = nullptr;
FILE *jpeg_fp;
jpeg_fp = fopen(jpeg_img_file_name.c_str(), "r");
if (!jpeg_fp)
{
std::cerr<<"Can not open "<<jpeg_img_file_name.c_str()<<std::endl;
}
fseek(jpeg_fp, 0L, SEEK_END);
unsigned int pJPEGBuffer_Size = ftell(jpeg_fp);
// printf("the jpg image data len: %d\n", pJPEGBuffer_Size);
// std::cout<<"the jpg image data len: "<<pJPEGBuffer_Size<<std::endl;
fseek(jpeg_fp, 0L, SEEK_SET);
pJPEGBuffer = new uint8_t[pJPEGBuffer_Size];
fread((char*)pJPEGBuffer, 1, pJPEGBuffer_Size, jpeg_fp);
fclose(jpeg_fp);
std::shared_ptr<FrameData> pJPEGFrameData = std::make_shared<FrameData>();
//组织数据,压入下一引擎
pJPEGFrameData->iDataSource = engineId_;
pJPEGFrameData->iSize = pJPEGBuffer_Size;
pJPEGFrameData->pData.reset(pJPEGBuffer, [](void* data){if(data) {delete[] data; data = nullptr;}}); //智能指针管理内存
// pJPEGFrameData->pData.reset(pJPEGBuffer, Deleter); //智能指针管理内存
pJPEGFrameData->i64TimeStamp = MyUtils::getins()->GetCurrentTimeMillis();
#if 1
iRet = outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pJPEGFrameData));
if (iRet != APP_ERR_OK){
LogError << "push the jpeg image data failed...";
std::cerr<<"push the jpeg image data failed..."<<std::endl;
}else{
// std::cout<<"push the jpeg image data success!"<<std::endl;
}
#endif
usleep(30 * 1000);
}
}
#else
//测试H264编码或者jpeg编码打开,并修改相应的yaml配置引擎间通信
APP_ERROR TestImgEngine::Process()
{
int iRet = APP_ERR_OK;
uint64_t u64count_num = 0;
while (!isStop_)
{
// std::cout<<"Enter Read Image Thread "<<++u64count_num<<" Times!"<<std::endl;
// std::cout<<"Read Image Thread ID: "<<std::this_thread::get_id()<<std::endl;
//读取图像
std::string yuv420m_img_file_name = MyYaml::GetIns()->GetStringValue("yuv420m_image_file_name");
//从本地文件读取yuv420m图像并构造yuv420m数据
void* pYUV420MBuffer = nullptr;
FILE *yuv420m_fp;
yuv420m_fp = fopen(yuv420m_img_file_name.c_str(), "rb");
if (!yuv420m_fp)
{
std::cerr<<"Can not open "<<yuv420m_img_file_name.c_str()<<std::endl;
}
fseek(yuv420m_fp, 0L, SEEK_END);
unsigned int pYUV420MBuffer_Size = ftell(yuv420m_fp);
// printf("test.yuv filesize = %d\n", pYUV420MBuffer_Size);
// std::cout<<"test.yuv filesize = "<<pYUV420MBuffer_Size<<std::endl;
fseek(yuv420m_fp, 0L, SEEK_SET);
pYUV420MBuffer = new uint8_t[pYUV420MBuffer_Size];
fread((char*)pYUV420MBuffer, 1, pYUV420MBuffer_Size, yuv420m_fp);
fclose(yuv420m_fp);
std::shared_ptr<FrameData> pYUV420MFrameData = std::make_shared<FrameData>();
//组织数据,压入下一引擎
pYUV420MFrameData->iDataSource = engineId_;
pYUV420MFrameData->iSize = pYUV420MBuffer_Size;
pYUV420MFrameData->pData.reset(pYUV420MBuffer, [](void* data){if(data) {delete[] data; data = nullptr;}}); //智能指针管理内存
// pYUV420MFrameData->pData.reset(pYUV420MBuffer, Deleter); //智能指针管理内存
pYUV420MFrameData->i64TimeStamp = MyUtils::getins()->GetCurrentTimeMillis();
#if 1
iRet = outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pYUV420MFrameData));
if (iRet != APP_ERR_OK){
LogError << "push the yuv420m image data failed...";
std::cerr<<"push the yuv420m image data failed..."<<std::endl;
}else{
// std::cout<<"push the yuv420m image data success!"<<std::endl;
}
#endif
usleep(30 * 1000);
}
}
#endif

45
nvidia_ascend_engine/nvidia_engine/DataSourceEngine/TestImgEngine.h Normal file
View File

@ -0,0 +1,45 @@
//读取图像引擎(用于测试)
#ifndef _TEST_IMG_ENGINE_H
#define _TEST_IMG_ENGINE_H
#include <iostream>
#include <chrono>
#include <cmath>
#include <utility>
#include <thread>
#include <chrono>
#include <functional>
#include <atomic>
#include <time.h>
#include <unistd.h>
#include <queue>
#include <mutex>
#include <semaphore.h>
#include "EngineBase.h"
#include "EngineFactory.h"
#include "MyYaml.h"
#include "myutils.h"
#include "AppCommon.h"
class TestImgEngine : public ai_matrix::EngineBase
{
public:
TestImgEngine();
~TestImgEngine();
APP_ERROR Init() override;
APP_ERROR DeInit() override;
APP_ERROR Process() override;
private:
ai_matrix::DataSourceConfig dataSourceConfig_;
std::string strPort0_;
unsigned int width_, height_;
};
ENGINE_REGIST(TestImgEngine)
#endif //END OF _TEST_IMG_ENGINE_H

109
nvidia_ascend_engine/nvidia_engine/DataSourceEngine/VideoEngine.cpp Normal file
View File

@ -0,0 +1,109 @@
#include "VideoEngine.h"
using namespace std;
using namespace cv;
using namespace ai_matrix;
VideoEngine::VideoEngine() {}
VideoEngine::~VideoEngine() {}
APP_ERROR VideoEngine::Init()
{
LogInfo << "engineId_:" << engineId_ << " VideoEngine Init start";
strPort0_ = engineName_ + "_" + std::to_string(engineId_) + "_0";
dataSourceConfig_ = MyYaml::GetIns()->GetDataSourceConfigById(engineId_); //获取摄像机参数
width_ = IMAGE_WIDTH, height_ = IMAGE_HEIGHT;
LogInfo << "engineId_:" << engineId_ << " VideoEngine Init ok";
return APP_ERR_OK;
}
APP_ERROR VideoEngine::DeInit()
{
LogInfo << "engineId_:" << engineId_ << " VideoEngine DeInit ok";
return APP_ERR_OK;
}
APP_ERROR VideoEngine::Process()
{
int iRet = APP_ERR_OK;
uint64_t u64count_num = 0;
// if (MyYaml::GetIns()->GetStringValue("gc_data_source") != "camera")
// {
// LogDebug << "engineId_:" << engineId_ << " gc_data_source no camera";
// return iRet;
// }
VideoCapture capture;
/*****************************************************************************************
Gstream解码
硬件解码方式:1.nvv4l2decoder 2.omxh264dec
使用nvv4l2decoder解码时enable-max-performance和enable-frame-type-reporting才可以使用
enable-max-performance=1 开启最大效率模式
enable-frame-type-reporting=1 使能帧数据汇报模式
*****************************************************************************************/
//从摄像头RTSP拉流
const std::string videoStreamAddress = std::string("rtspsrc location=") + dataSourceConfig_.strUrl.c_str() + " latency=10 ! \
rtph264depay ! h264parse ! nvv4l2decoder enable-max-performance=1 enable-frame-type-reporting=1 ! nvvidconv ! video/x-raw, format=(string)BGRx ! videoconvert ! appsink";
// while(!capture.open(dataSourceConfig_.strUrl.c_str())){
while(!capture.open(videoStreamAddress)){
std::cerr<<"Opening video stream or file failed!!!" <<std::endl;
std::cout<<"Restart Opening video stream or file ..."<<std::endl;
sleep(1);
}
std::cout<<"Opening video stream or file Success"<<std::endl;
int frameW = capture.get(3);
int frameH = capture.get(4);
std::cout << dataSourceConfig_.strUrl.c_str() << ";"<< "frameW:" << frameW << " frameH:" << frameH << std::endl;
while (!isStop_)
{
std::cout << dataSourceConfig_.strUrl.c_str() << ";"<< "frameW:" << frameW << " frameH:" << frameH << std::endl;
// std::cout<<"Enter VideoEngine Thread "<<++u64count_num<<" Times!"<<std::endl;
// std::cout<<"VideoEngine Thread ID: "<<std::this_thread::get_id()<<std::endl;
//构造BGR数据
void* pBGRBuffer = nullptr;
unsigned int pBGRBuffer_Size = width_*height_*3;
pBGRBuffer = new uint8_t[pBGRBuffer_Size];
std::shared_ptr<FrameData> pBGRFrameData = std::make_shared<FrameData>();
cv::Mat frame(frameH, frameW, CV_8UC3, pBGRBuffer);
// clock_t start, end;
// start = clock();
if(!capture.read(frame)) {
std::cerr << "no frame" << std::endl;
waitKey();
}
// end = clock();
// printf("read 1 frame time is %.8f ms\n", (double)(end-start)/CLOCKS_PER_SEC*1000);
//压入OpenCV RTSP所拉的H264解码BRG后的数据
//组织数据
pBGRFrameData->iDataSource = engineId_;
pBGRFrameData->iSize = pBGRBuffer_Size;
pBGRFrameData->pData.reset(pBGRBuffer, [](void* data){if(data) {delete[] data; data = nullptr;}}); //智能指针管理内存
// pBGRFrameData->pData.reset(pBGRBuffer, Deleter); //智能指针管理内存
pBGRFrameData->i64TimeStamp = MyUtils::getins()->GetCurrentTimeMillis();
iRet = outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pBGRFrameData));
if (iRet != APP_ERR_OK){
LogError << "push the bgr frame data failed...";
std::cerr<<"push the bgr frame data failed..."<<std::endl;
}else{
// std::cout<<"push the bgr frame data success!"<<std::endl;
}
// usleep(30*1000); //读取文件时模拟30帧
}
}

69
nvidia_ascend_engine/nvidia_engine/DataSourceEngine/VideoEngine.h Normal file
View File

@ -0,0 +1,69 @@
//OpenCV RTSP拉流引擎(包含视频解码)
#ifndef _VIDEO_ENGINE_H
#define _VIDEO_ENGINE_H
#include <iostream>
#include <chrono>
#include <cmath>
#include <utility>
#include <thread>
#include <chrono>
#include <functional>
#include <atomic>
#include <time.h>
#include <sys/time.h>
#include <unistd.h>
#include <queue>
#include <mutex>
#include <semaphore.h>
#include <algorithm>
#include <string>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <vector>
#include <memory>
#include <opencv2/opencv.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#ifdef __cplusplus
extern "C"
{
#endif
#include <libavcodec/avcodec.h>
#include <libavutil/samplefmt.h>
#include <libavformat/avformat.h>
#ifdef __cplusplus
};
#endif
#include "EngineBase.h"
#include "EngineFactory.h"
#include "MyYaml.h"
#include "myutils.h"
#include "AppCommon.h"
#define RTSP_PULL_CAMERA_VIDEO_STREAM
class VideoEngine : public ai_matrix::EngineBase
{
public:
VideoEngine();
~VideoEngine();
APP_ERROR Init() override;
APP_ERROR DeInit() override;
APP_ERROR Process() override;
private:
ai_matrix::DataSourceConfig dataSourceConfig_;
std::string strPort0_;
unsigned int width_, height_;
};
ENGINE_REGIST(VideoEngine)
#endif //_VIDEO_ENGINE_H

188
nvidia_ascend_engine/nvidia_engine/DecodeEngine/HardH264FFmpegDecode.cpp
View File

@ -2,54 +2,54 @@
using namespace std; using namespace std;
HardH264FFmpegDecode::HardH264FFmpegDecode() HardH264FFmpegDecode::HardH264FFmpegDecode()
{ {
; ;
} }
HardH264FFmpegDecode::~HardH264FFmpegDecode() HardH264FFmpegDecode::~HardH264FFmpegDecode()
{ {
; ;
} }
int HardH264FFmpegDecode::HardH264FFmpegDecoderInit(unsigned int uiWidth, unsigned int uiHeight, unsigned int uiFrameRate) int HardH264FFmpegDecode::HardH264FFmpegDecoderInit(unsigned int uiWidth, unsigned int uiHeight, unsigned int uiFrameRate)
{ {
uiWidth_ = uiWidth; uiHeight_ = uiHeight; uiWidth_ = uiWidth; uiHeight_ = uiHeight;
uiFrameRate_ = uiFrameRate; uiFrameRate_ = uiFrameRate;
iFrameFinished_ = 0; iFrameFinished_ = 0;
av_log_set_level(AV_LOG_ERROR); av_log_set_level(AV_LOG_ERROR);
// AVCodecID codec_id = AV_CODEC_ID_H264; //解码H264
// pCodec_ = avcodec_find_decoder(codec_id); //获取解码器
// AVCodecID codec_id = AV_CODEC_ID_H264; //解码H264 pCodec_ = avcodec_find_decoder_by_name(NVIDIA_H264_DECODER);
// pCodec_ = avcodec_find_decoder(codec_id); //获取解码器
pCodec_ = avcodec_find_decoder_by_name(NVIDIA_H264_DECODER);
if (!pCodec_) { if (!pCodec_) {
fprintf(stderr, "Codec '%s' not found\n", pCodec_->long_name); fprintf(stderr, "Codec '%s' not found\n", pCodec_->long_name);
exit(1); exit(1);
} }
printf("Codec found with name %d(%s)\n", pCodec_->id, pCodec_->long_name); printf("Codec found with name %d(%s)\n", pCodec_->id, pCodec_->long_name);
//创建上下文 //创建上下文
pCodecCtx_ = avcodec_alloc_context3(pCodec_); pCodecCtx_ = avcodec_alloc_context3(pCodec_);
if (!pCodecCtx_){ if (!pCodecCtx_){
fprintf(stderr, "Could not allocate video codec context\n"); fprintf(stderr, "Could not allocate video codec context\n");
exit(1); exit(1);
} }
//创建解析器 //创建解析器
pCodecParserCtx_ = av_parser_init(pCodec_->id); pCodecParserCtx_ = av_parser_init(pCodec_->id);
if (!pCodecParserCtx_){ if (!pCodecParserCtx_){
fprintf(stderr, "parser not found\n"); fprintf(stderr, "parser not found\n");
exit(1); exit(1);
} }
//if(pCodec_->capabilities&CODEC_CAP_TRUNCATED) //if(pCodec_->capabilities&CODEC_CAP_TRUNCATED)
// pCodecCtx_->flags|= CODEC_FLAG_TRUNCATED; // pCodecCtx_->flags|= CODEC_FLAG_TRUNCATED;
//打开解码器 //打开解码器
int ret = avcodec_open2(pCodecCtx_, pCodec_, nullptr); int ret = avcodec_open2(pCodecCtx_, pCodec_, nullptr);
if (ret < 0) { if (ret < 0) {
fprintf(stderr, "Could not open codec\n"); fprintf(stderr, "Could not open codec\n");
printf("avcodec_open2 ret is: %d\n",ret); printf("avcodec_open2 ret is: %d\n",ret);
exit(1); exit(1);
@ -63,7 +63,7 @@ int HardH264FFmpegDecode::HardH264FFmpegDecoderInit(unsigned int uiWidth, unsign
} }
// av_init_packet(pPacket_); // av_init_packet(pPacket_);
//分配frame //分配frame
pSrcFrame_ = av_frame_alloc(); pSrcFrame_ = av_frame_alloc();
if (!pSrcFrame_) { if (!pSrcFrame_) {
fprintf(stderr, "Could not allocate video src pFrame\n"); fprintf(stderr, "Could not allocate video src pFrame\n");
@ -78,14 +78,14 @@ int HardH264FFmpegDecode::HardH264FFmpegDecoderInit(unsigned int uiWidth, unsign
printf("after align down video_width: %d, video_height: %d\n", uiWidth_, uiHeight_); printf("after align down video_width: %d, video_height: %d\n", uiWidth_, uiHeight_);
//初始化解析器参数 //初始化解析器参数
pCodecCtx_->time_base.num = 1; pCodecCtx_->time_base.num = 1;
pCodecCtx_->frame_number = 1; //每包一个视频帧 pCodecCtx_->frame_number = 1; //每包一个视频帧
pCodecCtx_->codec_type = AVMEDIA_TYPE_VIDEO; pCodecCtx_->codec_type = AVMEDIA_TYPE_VIDEO;
pCodecCtx_->bit_rate = 0; pCodecCtx_->bit_rate = 0;
pCodecCtx_->time_base.den = uiFrameRate_;//帧率 pCodecCtx_->time_base.den = uiFrameRate_;//帧率
pCodecCtx_->width = uiWidth_; //视频宽 pCodecCtx_->width = uiWidth_; //视频宽
pCodecCtx_->height = uiHeight_; //视频高 pCodecCtx_->height = uiHeight_; //视频高
// pCodecCtx_->pix_fmt = AV_PIX_FMT_YUV420P; // pCodecCtx_->pix_fmt = AV_PIX_FMT_YUV420P;
int bufferSize = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, int bufferSize = av_image_get_buffer_size(AV_PIX_FMT_YUV420P,
@ -102,46 +102,46 @@ int HardH264FFmpegDecode::HardH264FFmpegDecoderInit(unsigned int uiWidth, unsign
printf("pDstFrame_->linesize: %d, bufferSize: %d\n", pDstFrame_->linesize, bufferSize); printf("pDstFrame_->linesize: %d, bufferSize: %d\n", pDstFrame_->linesize, bufferSize);
pSwsContext_ = sws_getContext(pCodecCtx_->width, pCodecCtx_->height, pCodecCtx_->pix_fmt, pSwsContext_ = sws_getContext(pCodecCtx_->width, pCodecCtx_->height, pCodecCtx_->pix_fmt,
pCodecCtx_->width, pCodecCtx_->height, AV_PIX_FMT_YUV420P, SWS_BICUBIC, nullptr, nullptr, nullptr); pCodecCtx_->width, pCodecCtx_->height, AV_PIX_FMT_YUV420P, SWS_BICUBIC, nullptr, nullptr, nullptr);
printf("pCodecCtx_->width: %d, pCodecCtx_->height: %d, pCodecCtx_->pix_fmt: %d\n", pCodecCtx_->width, pCodecCtx_->height, pCodecCtx_->pix_fmt); printf("pCodecCtx_->width: %d, pCodecCtx_->height: %d, pCodecCtx_->pix_fmt: %d\n", pCodecCtx_->width, pCodecCtx_->height, pCodecCtx_->pix_fmt);
return 0; return 0;
} }
int HardH264FFmpegDecode::HardH264FFmpegDecoderDeInit() int HardH264FFmpegDecode::HardH264FFmpegDecoderDeInit()
{ {
if(pu8OutBuffer_){ if(pu8OutBuffer_){
av_free(pu8OutBuffer_); av_free(pu8OutBuffer_);
pu8OutBuffer_ = nullptr; pu8OutBuffer_ = nullptr;
} }
if(pSrcFrame_){ if(pSrcFrame_){
av_frame_free(&pSrcFrame_); av_frame_free(&pSrcFrame_);
pSrcFrame_ = nullptr; pSrcFrame_ = nullptr;
} }
if(pDstFrame_){ if(pDstFrame_){
av_frame_free(&pDstFrame_); av_frame_free(&pDstFrame_);
pDstFrame_ = nullptr; pDstFrame_ = nullptr;
} }
if(pPacket_){ if(pPacket_){
av_packet_free(&pPacket_); av_packet_free(&pPacket_);
pPacket_ = nullptr; pPacket_ = nullptr;
} }
if(pCodecParserCtx_){ if(pCodecParserCtx_){
av_parser_close(pCodecParserCtx_); av_parser_close(pCodecParserCtx_);
pCodecParserCtx_ = nullptr; pCodecParserCtx_ = nullptr;
} }
if(pCodecCtx_){ if(pCodecCtx_){
avcodec_close(pCodecCtx_); avcodec_close(pCodecCtx_);
av_free(pCodecCtx_); av_free(pCodecCtx_);
pCodecCtx_ = nullptr; pCodecCtx_ = nullptr;
} }
if(pSwsContext_){ if(pSwsContext_){
sws_freeContext(pSwsContext_); sws_freeContext(pSwsContext_);
pSwsContext_ = nullptr; pSwsContext_ = nullptr;
} }
} }
int HardH264FFmpegDecode::HardH264FFmpegDecoderFilterGraph(AVFilterGraph *pGraph, AVFilterContext *pSourceCtx, AVFilterContext *pSinkCtx) int HardH264FFmpegDecode::HardH264FFmpegDecoderFilterGraph(AVFilterGraph *pGraph, AVFilterContext *pSourceCtx, AVFilterContext *pSinkCtx)
@ -149,7 +149,7 @@ int HardH264FFmpegDecode::HardH264FFmpegDecoderFilterGraph(AVFilterGraph *pGraph
int ret; int ret;
AVFilterInOut *pOutputs = nullptr, *pInputs = nullptr; AVFilterInOut *pOutputs = nullptr, *pInputs = nullptr;
if ((ret = avfilter_link(pSourceCtx, 0, pSinkCtx, 0)) >= 0){ if ((ret = avfilter_link(pSourceCtx, 0, pSinkCtx, 0)) >= 0){
ret = avfilter_graph_config(pGraph, nullptr); ret = avfilter_graph_config(pGraph, nullptr);
} }
avfilter_inout_free(&pOutputs); avfilter_inout_free(&pOutputs);
@ -168,14 +168,14 @@ int HardH264FFmpegDecode::HardH264FFmpegDecoderConfigureVideoFilters(AVFilterGra
"video_size=%dx%d:pix_fmt=%d:time_base=1/1200000", "video_size=%dx%d:pix_fmt=%d:time_base=1/1200000",
iWidth, iHeight, iFormat); iWidth, iHeight, iFormat);
if ((ret = avfilter_graph_create_filter(&pFiltSrc, if ((ret = avfilter_graph_create_filter(&pFiltSrc,
avfilter_get_by_name("buffer"), "ffplay_buffer", BufferSrcArgs, avfilter_get_by_name("buffer"), "ffplay_buffer", BufferSrcArgs,
nullptr, pGraph)) < 0){ nullptr, pGraph)) < 0){
goto fail; goto fail;
} }
ret = avfilter_graph_create_filter(&pFiltDst, ret = avfilter_graph_create_filter(&pFiltDst,
avfilter_get_by_name("buffersink"), avfilter_get_by_name("buffersink"),
"ffplay_buffersink", nullptr, nullptr, pGraph); "ffplay_buffersink", nullptr, nullptr, pGraph);
if (ret < 0){ if (ret < 0){
goto fail; goto fail;
} }
@ -190,14 +190,14 @@ int HardH264FFmpegDecode::HardH264FFmpegDecoderConfigureVideoFilters(AVFilterGra
pDecoderFilterIn = pFiltSrc; pDecoderFilterIn = pFiltSrc;
pDecoderFilterOut = pFiltDst; pDecoderFilterOut = pFiltDst;
fail: fail:
return ret; return ret;
} }
int HardH264FFmpegDecode::HardH264FFmpegDecoder(AVCodecContext *pDecCtx, AVFrame *pFrame, AVPacket *pPkt, void* pOutputData, unsigned int* puiOutputDataSize) int HardH264FFmpegDecode::HardH264FFmpegDecoder(AVCodecContext *pDecCtx, AVFrame *pFrame, AVPacket *pPkt, void* pOutputData, unsigned int* puiOutputDataSize)
{ {
int ret; int ret;
AVFilterGraph* pDecoderGraph = nullptr; AVFilterGraph* pDecoderGraph = nullptr;
ret = avcodec_send_packet(pDecCtx, pPkt); //接收packet解码 ret = avcodec_send_packet(pDecCtx, pPkt); //接收packet解码
if (ret < 0) { if (ret < 0) {
@ -208,7 +208,7 @@ int HardH264FFmpegDecode::HardH264FFmpegDecoder(AVCodecContext *pDecCtx, AVFrame
while (ret >= 0) { while (ret >= 0) {
ret = avcodec_receive_frame(pDecCtx, pFrame); //解码 ret = avcodec_receive_frame(pDecCtx, pFrame); //解码
if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF){ if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF){
fprintf(stderr, "During decoding eof\n"); fprintf(stderr, "During decoding eof\n");
return -1; return -1;
} }
else if (ret < 0) { else if (ret < 0) {
@ -219,35 +219,35 @@ int HardH264FFmpegDecode::HardH264FFmpegDecoder(AVCodecContext *pDecCtx, AVFrame
//printf("saving frame %3d\n", pDecCtx->frame_number); //printf("saving frame %3d\n", pDecCtx->frame_number);
fflush(stdout); fflush(stdout);
AVFilterContext *pDecoderFilterIn = nullptr, *pDecoderFilterOut = nullptr; AVFilterContext *pDecoderFilterIn = nullptr, *pDecoderFilterOut = nullptr;
// pFrame->width = ALIGN_DOWN(pFrame->width, 32); // pFrame->width = ALIGN_DOWN(pFrame->width, 32);
// pFrame->height = ALIGN_DOWN(pFrame->height, 32); // pFrame->height = ALIGN_DOWN(pFrame->height, 32);
// printf("pFrame->width: %d\tpFrame->height: %d\n", pFrame->width, pFrame->height); // printf("pFrame->width: %d\tpFrame->height: %d\n", pFrame->width, pFrame->height);
pDecoderGraph = avfilter_graph_alloc(); pDecoderGraph = avfilter_graph_alloc();
HardH264FFmpegDecoderConfigureVideoFilters(pDecoderGraph, pDecoderFilterIn, pDecoderFilterOut, pFrame->width, pFrame->height, pFrame->format); HardH264FFmpegDecoderConfigureVideoFilters(pDecoderGraph, pDecoderFilterIn, pDecoderFilterOut, pFrame->width, pFrame->height, pFrame->format);
if (pFrame->format != AV_PIX_FMT_YUV420P){ if (pFrame->format != AV_PIX_FMT_YUV420P){
DUMP_FRAME(pFrame); DUMP_FRAME(pFrame);
ret = av_buffersrc_add_frame(pDecoderFilterIn, pFrame); ret = av_buffersrc_add_frame(pDecoderFilterIn, pFrame);
ret = av_buffersink_get_frame_flags(pDecoderFilterOut, pFrame, 0); ret = av_buffersink_get_frame_flags(pDecoderFilterOut, pFrame, 0);
DUMP_FRAME(pFrame); DUMP_FRAME(pFrame);
int iSize = pFrame->width * pFrame->height; int iSize = pFrame->width * pFrame->height;
memcpy(pOutputData, pFrame->data[0], iSize); //Y memcpy(pOutputData, pFrame->data[0], iSize); //Y
memcpy(pOutputData+iSize, pFrame->data[1], iSize/4); //U memcpy(pOutputData+iSize, pFrame->data[1], iSize/4); //U
memcpy(pOutputData+iSize+iSize/4, pFrame->data[2], iSize/4); //V memcpy(pOutputData+iSize+iSize/4, pFrame->data[2], iSize/4); //V
*puiOutputDataSize = iSize*3/2; *puiOutputDataSize = iSize*3/2;
return iSize*3/2; return iSize*3/2;
} }
} }
return 0; return 0;
} }
int HardH264FFmpegDecode::HardH264FFmpegDecoderV2(AVCodecContext *pDecCtx, SwsContext *pSwsCtx, AVFrame *pSrcFrame, AVFrame *pDstFrame, AVPacket *pPkt, void* pOutputData,unsigned int* puiOutputDataSize) int HardH264FFmpegDecode::HardH264FFmpegDecoderV2(AVCodecContext *pDecCtx, SwsContext *pSwsCtx, AVFrame *pSrcFrame, AVFrame *pDstFrame, AVPacket *pPkt, void* pOutputData,unsigned int* puiOutputDataSize)
{ {
int ret; int ret;
ret = avcodec_send_packet(pDecCtx, pPkt); //接收packet解码 ret = avcodec_send_packet(pDecCtx, pPkt); //接收packet解码
if (ret < 0) { if (ret < 0) {
@ -258,7 +258,7 @@ int HardH264FFmpegDecode::HardH264FFmpegDecoderV2(AVCodecContext *pDecCtx, SwsCo
while (ret >= 0) { while (ret >= 0) {
ret = avcodec_receive_frame(pDecCtx, pSrcFrame); //解码 ret = avcodec_receive_frame(pDecCtx, pSrcFrame); //解码
if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF){ if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF){
fprintf(stderr, "During decoding eof\n"); fprintf(stderr, "During decoding eof\n");
return -1; return -1;
} }
else if (ret < 0) { else if (ret < 0) {
@ -266,7 +266,7 @@ int HardH264FFmpegDecode::HardH264FFmpegDecoderV2(AVCodecContext *pDecCtx, SwsCo
exit(1); exit(1);
} }
// pDecCtx->width = ALIGN_DOWN(pDecCtx->width, 32); // pDecCtx->width = ALIGN_DOWN(pDecCtx->width, 32);
// pDecCtx->height = ALIGN_DOWN(pDecCtx->height, 32); // pDecCtx->height = ALIGN_DOWN(pDecCtx->height, 32);
sws_scale(pSwsCtx, sws_scale(pSwsCtx,
@ -280,13 +280,13 @@ int HardH264FFmpegDecode::HardH264FFmpegDecoderV2(AVCodecContext *pDecCtx, SwsCo
//printf("saving frame %3d\n", pDecCtx->frame_number); //printf("saving frame %3d\n", pDecCtx->frame_number);
fflush(stdout); fflush(stdout);
int iSize = pDecCtx->width * pDecCtx->height; int iSize = pDecCtx->width * pDecCtx->height;
memcpy(pOutputData, pDstFrame->data[0], iSize); //Y memcpy(pOutputData, pDstFrame->data[0], iSize); //Y
memcpy(pOutputData+iSize, pDstFrame->data[1], iSize/4); //U memcpy(pOutputData+iSize, pDstFrame->data[1], iSize/4); //U
memcpy(pOutputData+iSize+iSize/4, pDstFrame->data[2], iSize/4); //V memcpy(pOutputData+iSize+iSize/4, pDstFrame->data[2], iSize/4); //V
*puiOutputDataSize = iSize*3/2; *puiOutputDataSize = iSize*3/2;
return iSize*3/2; return iSize*3/2;
} }
return 0; return 0;
} }

18
nvidia_ascend_engine/nvidia_engine/DecodeEngine/HardH264FFmpegDecode.h
View File

@ -56,7 +56,7 @@ extern "C"
frame->linesize[2] \ frame->linesize[2] \
);} );}
#define NVIDIA_H264_DECODER "h264_cuvid" #define NVIDIA_H264_DECODER "h264_cuvid"
// #define NVIDIA_H264_DECODER "h264_v4l2m2m" // #define NVIDIA_H264_DECODER "h264_v4l2m2m"
class HardH264FFmpegDecode class HardH264FFmpegDecode
@ -69,21 +69,21 @@ public:
int HardH264FFmpegDecoderDeInit(); int HardH264FFmpegDecoderDeInit();
int HardH264FFmpegDecoder(AVCodecContext *pDecCtx, AVFrame *pFrame, AVPacket *pPkt, void* pOutputData, unsigned int* puiOutputDataSize); int HardH264FFmpegDecoder(AVCodecContext *pDecCtx, AVFrame *pFrame, AVPacket *pPkt, void* pOutputData, unsigned int* puiOutputDataSize);
int HardH264FFmpegDecoderV2(AVCodecContext *pDecCtx, SwsContext *pSwsCtx, AVFrame *pSrcFrame, AVFrame *pDstFrame, AVPacket *pPkt, void* pOutputData, unsigned int* puiOutputDataSize); int HardH264FFmpegDecoderV2(AVCodecContext *pDecCtx, SwsContext *pSwsCtx, AVFrame *pSrcFrame, AVFrame *pDstFrame, AVPacket *pPkt, void* pOutputData, unsigned int* puiOutputDataSize);
const AVCodec *pCodec_ = nullptr; //解码器 const AVCodec *pCodec_ = nullptr; //解码器
AVCodecContext *pCodecCtx_ = nullptr; //上下文 AVCodecContext *pCodecCtx_ = nullptr; //上下文
AVCodecParserContext *pCodecParserCtx_ = nullptr; //解析器上下文 AVCodecParserContext *pCodecParserCtx_ = nullptr; //解析器上下文
AVFrame *pSrcFrame_ = nullptr; AVFrame *pSrcFrame_ = nullptr;
AVFrame *pDstFrame_ = nullptr; AVFrame *pDstFrame_ = nullptr;
AVPacket *pPacket_ = nullptr; AVPacket *pPacket_ = nullptr;
SwsContext *pSwsContext_ = nullptr; SwsContext *pSwsContext_ = nullptr;
uint8_t *pu8OutBuffer_ = nullptr; uint8_t *pu8OutBuffer_ = nullptr;
private: private:
int HardH264FFmpegDecoderFilterGraph(AVFilterGraph *pGraph, AVFilterContext *pSourceCtx, AVFilterContext *pSinkCtx); int HardH264FFmpegDecoderFilterGraph(AVFilterGraph *pGraph, AVFilterContext *pSourceCtx, AVFilterContext *pSinkCtx);
int HardH264FFmpegDecoderConfigureVideoFilters(AVFilterGraph *pGraph, AVFilterContext* &pDecoderFilterIn, AVFilterContext* &pDecoderFilterOut, const int iWidth, const int iHeight, const int iFormat); int HardH264FFmpegDecoderConfigureVideoFilters(AVFilterGraph *pGraph, AVFilterContext* &pDecoderFilterIn, AVFilterContext* &pDecoderFilterOut, const int iWidth, const int iHeight, const int iFormat);
unsigned int uiWidth_, uiHeight_; unsigned int uiWidth_, uiHeight_;
int iFrameFinished_; int iFrameFinished_;

32
nvidia_ascend_engine/nvidia_engine/DecodeEngine/VideoDecodeEngine.cpp
View File

@ -56,7 +56,7 @@ APP_ERROR VideoDecodeEngine::Process()
} }
int iRet = APP_ERR_OK; int iRet = APP_ERR_OK;
int iSkipCount = 1; int iSkipCount = 1;
int iNoCameraDataCnt = 0; int iNoCameraDataCnt = 0;
while (!isStop_) while (!isStop_)
{ {
@ -67,19 +67,19 @@ APP_ERROR VideoDecodeEngine::Process()
{ {
usleep(10*1000); //10ms usleep(10*1000); //10ms
// iNoCameraDataCnt++; iNoCameraDataCnt++;
// if (iNoCameraDataCnt >= 1000) //10秒内收不到，认为相机断开 if (iNoCameraDataCnt >= 1000) //10秒内收不到，认为相机断开
// { {
// LogError << "engineId:" << engineId_ << " 超过10秒获取到摄像头数据，疑似摄像头断开。计数：" << iNoCameraDataCnt; LogError << "engineId:" << engineId_ << " 超过10秒获取到摄像头数据，疑似摄像头断开。计数：" << iNoCameraDataCnt;
// iNoCameraDataCnt = 0; iNoCameraDataCnt = 0;
// //camera异常时，构造空的解码数据push，确保一直有数据流转到后面Engine //camera异常时，构造空的解码数据push，确保一直有数据流转到后面Engine
// std::shared_ptr<ProcessData> pProcessData = std::make_shared<ProcessData>(); std::shared_ptr<ProcessData> pProcessData = std::make_shared<ProcessData>();
// pProcessData->iDataSource = engineId_; pProcessData->iDataSource = engineId_;
// pProcessData->i64TimeStamp = MyUtils::getins()->GetCurrentTimeMillis(); pProcessData->i64TimeStamp = MyUtils::getins()->GetCurrentTimeMillis();
// pProcessData->iSize = 0; pProcessData->iSize = 0;
// pProcessData->pData = nullptr; pProcessData->pData = nullptr;
// iRet = outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pProcessData)); iRet = outputQueMap_[strPort0_]->push(std::static_pointer_cast<void>(pProcessData));
// } }
continue; continue;
} }
@ -111,8 +111,8 @@ APP_ERROR VideoDecodeEngine::Process()
std::shared_ptr<void> pYUVData; std::shared_ptr<void> pYUVData;
pYUVData.reset(pYUV420MBuffer, [](void *data){if(data) {delete[] data; data = nullptr;}}); //智能指针管理内存 pYUVData.reset(pYUV420MBuffer, [](void *data){if(data) {delete[] data; data = nullptr;}}); //智能指针管理内存
hard_h264_ffmpeg_decoder_->pPacket_->data = static_cast<uint8_t *>(pProcessData->pData.get()); //这里填入一个指向完整H264数据帧的指针 hard_h264_ffmpeg_decoder_->pPacket_->data = static_cast<uint8_t *>(pProcessData->pData.get()); //这里填入一个指向完整H264数据帧的指针
hard_h264_ffmpeg_decoder_->pPacket_->size = pProcessData->iSize; //这个填入H264数据帧的大小 hard_h264_ffmpeg_decoder_->pPacket_->size = pProcessData->iSize; //这个填入H264数据帧的大小
// H264硬件解码 // H264硬件解码
// int iDecodeRet= hard_h264_ffmpeg_decoder_->HardH264FFmpegDecoderV2(hard_h264_ffmpeg_decoder_->pCodecCtx_, hard_h264_ffmpeg_decoder_->pFrame_, // int iDecodeRet= hard_h264_ffmpeg_decoder_->HardH264FFmpegDecoderV2(hard_h264_ffmpeg_decoder_->pCodecCtx_, hard_h264_ffmpeg_decoder_->pFrame_,

34
nvidia_ascend_engine/nvidia_engine/MoveEngine/MoveEngine.cpp
View File

@ -51,7 +51,7 @@ APP_ERROR MoveEngine::Init()
} }
InitParam(); InitParam();
LogInfo << "MoveEngine Init ok"; LogInfo << "MoveEngine Init ok";
return APP_ERR_OK; return APP_ERR_OK;
} }
@ -111,8 +111,13 @@ APP_ERROR MoveEngine::ReadModelInfo()
model_width = jvModelInfo["model_width"].asInt(); model_width = jvModelInfo["model_width"].asInt();
model_height = jvModelInfo["model_height"].asInt(); model_height = jvModelInfo["model_height"].asInt();
//clear_num = jvModelInfo["clear"].isArray() ? jvModelInfo["clear"].size() : 0;
//class_num = jvModelInfo["class"].isArray() ? jvModelInfo["class"].size() : 0;
input_size = GET_INPUT_SIZE(model_width , model_height); input_size = GET_INPUT_SIZE(model_width , model_height);
output_size = GET_OUTPUT_SIZE(model_width , model_height, clear_num , class_num); output_size = GET_OUTPUT_SIZE(model_width , model_height, clear_num , class_num);
// det_size = clear_num + class_num + 5;
// score_threshold = modelConfig_.fScoreThreshold;
// nms_threshold = modelConfig_.fNMSTreshold;
return APP_ERR_OK; return APP_ERR_OK;
} }
@ -141,8 +146,8 @@ void MoveEngine::InitParam()
} }
void MoveEngine::sendComeTrain() { void MoveEngine::sendComeTrain() {
std::string message = "{\"cometime\":\"" + this->strTrainDate_ + " " + this->strTrainName_ + "\",\"type\":\"1\"}"; // std::string message = "{\"cometime\":" + this->strTrainDate_ + " " + this->strTrainName_ + "\",\"type\":\"1\"}";
outputQueMap_[engineName_ + "_" + std::to_string(engineId_) + "_1"]->push(std::static_pointer_cast<void>(std::make_shared<std::string>(message))); // outputQueMap_[engineName_ + "_" + std::to_string(engineId_) + "_1"]->push(std::static_pointer_cast<void>(std::make_shared<std::string>(message)));
} }
void MoveEngine::sendEndTrain() { void MoveEngine::sendEndTrain() {
@ -192,7 +197,7 @@ void MoveEngine::SingleDeviceProcess(std::shared_ptr<ProcessData> pProcessData,
{ {
outputQueMap_[engineName_ + "_" + std::to_string(engineId_) + "_" + std::to_string(*iter)]->push(std::static_pointer_cast<void>(pMoveData)); outputQueMap_[engineName_ + "_" + std::to_string(engineId_) + "_" + std::to_string(*iter)]->push(std::static_pointer_cast<void>(pMoveData));
} }
//通知第一步开始识别 //通知第一步开始识别
outputQueMap_[engineName_ + "_" + std::to_string(engineId_) + "_5"]->push(std::static_pointer_cast<void>(pMoveData)); outputQueMap_[engineName_ + "_" + std::to_string(engineId_) + "_5"]->push(std::static_pointer_cast<void>(pMoveData));
} }
@ -269,7 +274,6 @@ APP_ERROR MoveEngine::Process()
memset(fReturnVal, 0x00, sizeof(fReturnVal)); memset(fReturnVal, 0x00, sizeof(fReturnVal));
yolov8model.YoloV8InferenceModelGetType(img, fReturnVal, STEP0_OUTPUT_ARRAY * sizeof(float)); yolov8model.YoloV8InferenceModelGetType(img, fReturnVal, STEP0_OUTPUT_ARRAY * sizeof(float));
// exit(0);
float fScore = 0.0f; float fScore = 0.0f;
for(int n = 0; n < 4; n++){ for(int n = 0; n < 4; n++){
@ -278,7 +282,7 @@ APP_ERROR MoveEngine::Process()
nType = n; nType = n;
} }
} }
// LogDebug <<"模型得分 车头:"<< fReturnVal[0]<<" 无车:"<< fReturnVal[1]<<" 车尾:"<< fReturnVal[2]<<" 有车:"<< fReturnVal[3]; LogDebug <<"模型得分 车头:"<< fReturnVal[0]<<" 无车:"<< fReturnVal[1]<<" 车尾:"<< fReturnVal[2]<<" 有车:"<< fReturnVal[3];
// LogInfo<<"来车当前状态:"<< (nType == 0 ? "有车头" : (nType == 1 ? "无车")); // LogInfo<<"来车当前状态:"<< (nType == 0 ? "有车头" : (nType == 1 ? "无车"));
switch (nType) { switch (nType) {
case 0: case 0:
@ -311,7 +315,7 @@ APP_ERROR MoveEngine::Process()
if (bGetTrainExist == true) if (bGetTrainExist == true)
{ {
iHasTrainNum_ = iHasTrainNum_ > 20 ? iHasTrainNum_ : iHasTrainNum_ + 1; iHasTrainNum_ = iHasTrainNum_ > 20 ? iHasTrainNum_ : iHasTrainNum_ + 1;
// if (iHasTrainNum_ > 0) LogDebug << "当前有车, 计数：" << iHasTrainNum_; if (iHasTrainNum_ > 0) LogDebug << "当前有车, 计数：" << iHasTrainNum_;
} }
else else
{ {
@ -330,33 +334,33 @@ APP_ERROR MoveEngine::Process()
{ {
queProcessData_.push(pProcessData); queProcessData_.push(pProcessData);
LogDebug << "iStepInter_: " << iStepInter_ << " queSize:" << queProcessData_.size() << " continue"; LogDebug << "iStepInter_: " << iStepInter_ << " queSize:" << queProcessData_.size() << " continue";
continue; continue;
} }
if (iStepInter_ != 1) this->sendComeTrain(); // if (iStepInter_ != 1) this->sendComeTrain();
iStepInter_ = 1; iStepInter_ = 1;
} }
//无车停止识别 //无车停止识别
else else
{ {
if (iStepInter_ == 1) if (iStepInter_ == 1)
{ {
iStepInter_ = 2; iStepInter_ = 2;
this->sendEndTrain();
} }
while (!queProcessData_.empty()) while (!queProcessData_.empty())
{ {
LogDebug << "while iStepInter_: " << iStepInter_ << " queSize:" << queProcessData_.size(); LogDebug << "while iStepInter_: " << iStepInter_ << " queSize:" << queProcessData_.size();
queProcessData_.pop(); queProcessData_.pop();
} }
this->sendEndTrain();
} }
//有车识别处理 //有车识别处理
if (iStepInter_ != 0) if (iStepInter_ != 0)
{ {
while (!queProcessData_.empty()) while (!queProcessData_.empty())
{ {
LogDebug << "while2 iStepInter_: " << iStepInter_ << " queSize:" << queProcessData_.size(); LogDebug << "while2 iStepInter_: " << iStepInter_ << " queSize:" << queProcessData_.size();
std::shared_ptr<ProcessData> pProcessDataTemp = queProcessData_.front(); std::shared_ptr<ProcessData> pProcessDataTemp = queProcessData_.front();
queProcessData_.pop(); queProcessData_.pop();
pProcessDataTemp->iStatus = TRAINSTATUS_RUN; pProcessDataTemp->iStatus = TRAINSTATUS_RUN;
@ -368,7 +372,7 @@ APP_ERROR MoveEngine::Process()
pProcessData->bIsEnd = ((iStepInter_ == 2) ? true : false); //动态检测无车，设置列车结束标识 pProcessData->bIsEnd = ((iStepInter_ == 2) ? true : false); //动态检测无车，设置列车结束标识
SingleDeviceProcess(pProcessData, nType); SingleDeviceProcess(pProcessData, nType);
if (iStepInter_ == 2) if (iStepInter_ == 2)
{ {
// this->sendEndTrain(); // this->sendEndTrain();

111
nvidia_ascend_engine/nvidia_engine/TrainStepOneEngine/TrainStepOneEngine.cpp
View File

@ -14,7 +14,7 @@ APP_ERROR TrainStepOneEngine::Init()
bUseEngine_ = MyUtils::getins()->ChkIsHaveTarget("NUM"); bUseEngine_ = MyUtils::getins()->ChkIsHaveTarget("NUM");
if (!bUseEngine_) if (!bUseEngine_)
{ {
LogInfo << "engineId_:" << engineId_ << " not use engine"; LogWarn << "engineId_:" << engineId_ << " not use engine";
return APP_ERR_OK; return APP_ERR_OK;
} }
@ -98,7 +98,7 @@ APP_ERROR TrainStepOneEngine::InitModel()
int nRet = yolov5model.YoloV5ClearityInferenceInit(&modelinfo, strModelName, modelConfig_.strOmPath); int nRet = yolov5model.YoloV5ClearityInferenceInit(&modelinfo, strModelName, modelConfig_.strOmPath);
if (nRet != 0) if (nRet != 0)
{ {
LogError << "YoloV5ClassifyInferenceInit nRet:" << nRet; LogInfo << "YoloV5ClassifyInferenceInit nRet:" << nRet;
return APP_ERR_COMM_READ_FAIL; return APP_ERR_COMM_READ_FAIL;
} }
return APP_ERR_OK; return APP_ERR_OK;
@ -147,7 +147,7 @@ APP_ERROR TrainStepOneEngine::DeInit()
{ {
if (!bUseEngine_) if (!bUseEngine_)
{ {
LogInfo << "engineId_:" << engineId_ << " not use engine"; LogWarn << "engineId_:" << engineId_ << " not use engine";
return APP_ERR_OK; return APP_ERR_OK;
} }
@ -170,7 +170,7 @@ void TrainStepOneEngine::PushData(const std::string &strPort, const std::shared_
int iRet = outputQueMap_[strPort]->push(std::static_pointer_cast<void>(pProcessData)); int iRet = outputQueMap_[strPort]->push(std::static_pointer_cast<void>(pProcessData));
if (iRet != 0) if (iRet != 0)
{ {
LogError << " frameid:" << pProcessData->iFrameId << " push fail iRet:" << iRet; LogDebug << "sourceid:" << pProcessData->iDataSource << " frameid:" << pProcessData->iFrameId << " push fail iRet:" << iRet;
if (iRet == 2) if (iRet == 2)
{ {
usleep(10000); // 10ms usleep(10000); // 10ms
@ -194,7 +194,7 @@ void TrainStepOneEngine::FilterInvalidInfo(std::vector<stDetection> &vecRet, std
std::vector<stDetection> vecSpaceInfo; std::vector<stDetection> vecSpaceInfo;
for (auto it = vecRet.begin(); it != vecRet.end();) for (auto it = vecRet.begin(); it != vecRet.end();)
{ {
LogDebug << "frameId:" << pProcessData->iFrameId LogDebug << "sourceid:" << pProcessData->iDataSource << " frameId:" << pProcessData->iFrameId
<< " bigclassid:" << it->class_id << " ltx:" << it->bbox[0] << " lty:" << it->bbox[1] << " bigclassid:" << it->class_id << " ltx:" << it->bbox[0] << " lty:" << it->bbox[1]
<< " rbx:" << it->bbox[2] << " rby:" << it->bbox[3]; << " rbx:" << it->bbox[2] << " rby:" << it->bbox[3];
// 根据配置文件中 设置的识别范围，过滤掉无效数据 // 根据配置文件中 设置的识别范围，过滤掉无效数据
@ -203,75 +203,49 @@ void TrainStepOneEngine::FilterInvalidInfo(std::vector<stDetection> &vecRet, std
it->bbox[2] <= dataSourceCfg.fIdentifyAreasRBX && it->bbox[2] <= dataSourceCfg.fIdentifyAreasRBX &&
it->bbox[3] <= dataSourceCfg.fIdentifyAreasRBY)) it->bbox[3] <= dataSourceCfg.fIdentifyAreasRBY))
{ {
LogDebug << "frameId:" << pProcessData->iFrameId LogWarn << "sourceid:" << pProcessData->iDataSource << " frameId:" << pProcessData->iFrameId
<< " bigclassid:" << it->class_id << " 超出识别区域-识别区域：(" << " bigclassid:" << it->class_id << " invalid areas";
<< dataSourceCfg.fIdentifyAreasLTX << "," << dataSourceCfg.fIdentifyAreasLTY << "),("
<< dataSourceCfg.fIdentifyAreasRBX << "," << dataSourceCfg.fIdentifyAreasRBY << ")";
it = vecRet.erase(it); it = vecRet.erase(it);
continue; continue;
} }
// 如果设置了不识别车头，则去掉车头标记的大框 // 去除车头车尾的间隔信息
if (!MyYaml::GetIns()->GetBoolValue("gc_train_heard_detect") && it->class_id == TRAIN_HEAD)
{
LogDebug << "frameId:" << pProcessData->iFrameId << " 过滤掉车头编号";
it = vecRet.erase(it);
continue;
}
// 去除车头时的非车头编号信息
if(pProcessData->nMonitorState == MONITOR_MODEL_TRAIN_HEAD ) if(pProcessData->nMonitorState == MONITOR_MODEL_TRAIN_HEAD )
{ {
if(it->class_id != TRAIN_HEAD) LogWarn<<" pProcessData->nMonitorState:" << pProcessData->nMonitorState;
if(it->class_id != TRAIN_HEAD)
{ {
LogDebug << " 帧号:" << pProcessData->iFrameId LogError << "sourceid:" << pProcessData->iDataSource << " frameId:" << pProcessData->iFrameId
<< " 大类:" << it->class_id << " 识别于车头位置，无效！"; << " bigclassid:" << it->class_id << " pProcessData->nMonitorState:" << pProcessData->nMonitorState
<< " invalid";
it = vecRet.erase(it); it = vecRet.erase(it);
continue; continue;
} }
} }
if (pProcessData->nMonitorState == MONITOR_MODEL_TRAIN_TAIL )
// 去除车尾的车头编号信息
if (pProcessData->nMonitorState != MONITOR_MODEL_TRAIN_HEAD)
{ {
if (it->class_id == TRAIN_HEAD) LogWarn<<" pProcessData->nMonitorState:" << pProcessData->nMonitorState;
/*if(
(it->class_id <= U_TRAIN_SPACE)
&& (it->class_id >= C_TRAIN_SPACE)
&& (it->class_id != W_TRAIN_NUM)
)*/
{ {
LogDebug << " 帧号:" << pProcessData->iFrameId LogError << "sourceid:" << pProcessData->iDataSource << " frameId:" << pProcessData->iFrameId
<< " 大类:" << it->class_id << " 识别于非车头位置，无效！"; << " bigclassid:" << it->class_id << " pProcessData->nMonitorState:" << pProcessData->nMonitorState
<< " invalid";
it = vecRet.erase(it); it = vecRet.erase(it);
continue; continue;
} }
} }
// 去除车尾的间隔信息
if (pProcessData->nMonitorState == MONITOR_MODEL_TRAIN_TAIL
&& ((it->class_id >= 9 && it->class_id <= 17 && it->class_id != 15) || it->class_id == 18))
{
LogDebug << " frameId:" << pProcessData->iFrameId
<< " bigclassid:" << it->class_id
<<" 识别于车尾部分,无效！";
it = vecRet.erase(it);
continue;
}
// 过滤掉识别于模型反馈无车状态下的所有大框信息
if (pProcessData->nMonitorState == MONITOR_MODEL_NO_TRAIN)
{
LogDebug << " frameId:" << pProcessData->iFrameId
<< " bigclassid:" << it->class_id
<<" 识别于模型反馈的无车状态下,无效！";
it = vecRet.erase(it);
continue;
}
// 按大框高度剔除远股道识别的信息 // 按大框高度剔除远股道识别的信息
int iClassHeight = it->bbox[3] - it->bbox[1]; int iClassHeight = it->bbox[3] - it->bbox[1];
if (dataSourceCfg.mapClassMinH.find(it->class_id) != dataSourceCfg.mapClassMinH.end() && if (dataSourceCfg.mapClassMinH.find(it->class_id) != dataSourceCfg.mapClassMinH.end() &&
iClassHeight < dataSourceCfg.mapClassMinH[it->class_id]) iClassHeight < dataSourceCfg.mapClassMinH[it->class_id])
{ {
LogDebug << " frameId:" << pProcessData->iFrameId LogError << "sourceid:" << pProcessData->iDataSource << " frameId:" << pProcessData->iFrameId
<< " bigclassid:" << it->class_id << " iClassHeight:" << iClassHeight << " bigclassid:" << it->class_id << " iClassHeight:" << iClassHeight
<< " minH:" << dataSourceCfg.mapClassMinH[it->class_id] << " 过滤疑似远股道识别"; << " minH:" << dataSourceCfg.mapClassMinH[it->class_id] << " invalid hegiht";
it = vecRet.erase(it); it = vecRet.erase(it);
continue; continue;
} }
@ -282,7 +256,7 @@ void TrainStepOneEngine::FilterInvalidInfo(std::vector<stDetection> &vecRet, std
{ {
if (it->class_id != 1 && it->class_id != 6) if (it->class_id != 1 && it->class_id != 6)
{ {
LogDebug << " frameId:" << pProcessData->iFrameId << " flat camera only deal 1 or 6"; LogDebug << "sourceid:" << pProcessData->iDataSource << " frameId:" << pProcessData->iFrameId << " flat camera only deal 1 or 6";
it = vecRet.erase(it); it = vecRet.erase(it);
continue; continue;
} }
@ -292,13 +266,13 @@ void TrainStepOneEngine::FilterInvalidInfo(std::vector<stDetection> &vecRet, std
if (((it->class_id >= 2 && it->class_id <= 6) || it->class_id == J_TRAIN_NUM || it->class_id == W_TRAIN_NUM) && if (((it->class_id >= 2 && it->class_id <= 6) || it->class_id == J_TRAIN_NUM || it->class_id == W_TRAIN_NUM) &&
(it->bbox[3] - it->bbox[1]) > (it->bbox[2] - it->bbox[0])) (it->bbox[3] - it->bbox[1]) > (it->bbox[2] - it->bbox[0]))
{ {
LogWarn << " frameId:" << pProcessData->iFrameId LogWarn << "sourceid:" << pProcessData->iDataSource << " frameId:" << pProcessData->iFrameId
<< " bigclassid:" << it->class_id << " 过滤 高度大于宽度的车号"; << " bigclassid:" << it->class_id << " invalid data-- height > width ";
it = vecRet.erase(it); it = vecRet.erase(it);
continue; continue;
} }
if (((it->class_id >= 2 && it->class_id <= 6) || it->class_id == J_TRAIN_NUM || it->class_id == W_TRAIN_NUM) && if (((it->class_id >= 2 && it->class_id <= 6) || it->class_id == J_TRAIN_NUM || it->class_id == W_TRAIN_NUM) &&
(it->bbox[3] - it->bbox[1]) < MyYaml::GetIns()->GetIntValue("gc_num_frame_height")) (it->bbox[3] - it->bbox[1]) < MyYaml::GetIns()->GetIntValue("gc_num_frame_height"))
{ {
LogWarn << "疑似误识别到远股道车号，帧号:" << pProcessData->iFrameId LogWarn << "疑似误识别到远股道车号，帧号:" << pProcessData->iFrameId
<< "大框高度:" << (it->bbox[3] - it->bbox[1]); << "大框高度:" << (it->bbox[3] - it->bbox[1]);
@ -307,7 +281,7 @@ void TrainStepOneEngine::FilterInvalidInfo(std::vector<stDetection> &vecRet, std
} }
if ((it->class_id == 1 || it->class_id == TRAIN_PRO) if ((it->class_id == 1 || it->class_id == TRAIN_PRO)
&& (it->bbox[3] - it->bbox[1]) < MyYaml::GetIns()->GetIntValue("gc_pro_frame_height")) { && (it->bbox[3] - it->bbox[1]) < MyYaml::GetIns()->GetIntValue("gc_pro_frame_height")) {
LogWarn << "疑似误识别到远股道属性，帧号:" << pProcessData->iFrameId LogWarn << "疑似误识别到远股道属性，帧号:" << pProcessData->iFrameId
<< "大框高度:" << (it->bbox[3] - it->bbox[1]); << "大框高度:" << (it->bbox[3] - it->bbox[1]);
it = vecRet.erase(it); it = vecRet.erase(it);
@ -327,8 +301,8 @@ void TrainStepOneEngine::FilterInvalidInfo(std::vector<stDetection> &vecRet, std
{ {
if (it->bbox[3] < (pProcessData->iHeight * iSpaceMinRBXPer_ / 100)) if (it->bbox[3] < (pProcessData->iHeight * iSpaceMinRBXPer_ / 100))
{ {
LogWarn << " frameId:" << pProcessData->iFrameId LogWarn << "sourceid:" << pProcessData->iDataSource << " frameId:" << pProcessData->iFrameId
<< " bigclassid:" << it->class_id << " 过滤间隔过于靠下的间隔信息 fRBY:" << it->bbox[3]; << " bigclassid:" << it->class_id << " spaceinfo invalid fRBY:" << it->bbox[3];
it = vecRet.erase(it); it = vecRet.erase(it);
continue; continue;
} }
@ -346,10 +320,10 @@ void TrainStepOneEngine::FilterInvalidInfo(std::vector<stDetection> &vecRet, std
int iCenterY = pProcessData->iHeight / 2; int iCenterY = pProcessData->iHeight / 2;
if (iHeight0 < iCenterY && iHeight1 < iCenterY) //非平车 if (iHeight0 < iCenterY && iHeight1 < iCenterY) //非平车
{ {
if (!((vecRet[0].class_id >= 9 && vecRet[0].class_id <= 17 && vecRet[0].class_id != 15) || vecRet[0].class_id == U_TRAIN_SPACE) && if (!((vecRet[0].class_id >= 9 && vecRet[0].class_id <= 17 && vecRet[0].class_id != 15) || vecRet[0].class_id == U_TRAIN_SPACE) &&
!((vecRet[1].class_id >= 9 && vecRet[1].class_id <= 17 && vecRet[1].class_id != 15) || vecRet[1].class_id == U_TRAIN_SPACE)) !((vecRet[1].class_id >= 9 && vecRet[10].class_id <= 17 && vecRet[1].class_id != 15) || vecRet[1].class_id == U_TRAIN_SPACE))
{ {
LogDebug << " frameId:" << pProcessData->iFrameId << " no space"; LogError << "sourceid:" << pProcessData->iDataSource << " frameId:" << pProcessData->iFrameId << " no space";
vecRet.clear(); vecRet.clear();
} }
} }
@ -413,7 +387,7 @@ APP_ERROR TrainStepOneEngine::Process()
{ {
if (!bUseEngine_) if (!bUseEngine_)
{ {
LogInfo << "engineId_:" << engineId_ << " not use engine"; LogWarn << "engineId_:" << engineId_ << " not use engine";
return APP_ERR_OK; return APP_ERR_OK;
} }
int iRet = APP_ERR_OK; int iRet = APP_ERR_OK;
@ -434,7 +408,7 @@ APP_ERROR TrainStepOneEngine::Process()
pPostData->iModelType = MODELTYPE_NUM; pPostData->iModelType = MODELTYPE_NUM;
pPostData->nMonitorState = pProcessData->nMonitorState; //来车检测的四个分类 pPostData->nMonitorState = pProcessData->nMonitorState; //来车检测的四个分类
//获取图片 //获取图片
if (pProcessData->iStatus == TRAINSTATUS_RUN || pProcessData->bIsEnd) if (pProcessData->iStatus == TRAINSTATUS_RUN || pProcessData->bIsEnd)
{ {
if (pProcessData->pData != nullptr && pProcessData->iSize != 0) if (pProcessData->pData != nullptr && pProcessData->iSize != 0)
@ -443,7 +417,10 @@ APP_ERROR TrainStepOneEngine::Process()
//进行推理 //进行推理
std::vector<stDetection> res; std::vector<stDetection> res;
//auto start = std::chrono::system_clock::now(); //计时开始
yolov5model.YoloV5ClearityInferenceModel(img, res); yolov5model.YoloV5ClearityInferenceModel(img, res);
//auto end = std::chrono::system_clock::now();
//LogInfo << "nopr1 inference time: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms";
//过滤无效信息 //过滤无效信息
FilterInvalidInfo(res, pProcessData); FilterInvalidInfo(res, pProcessData);
@ -484,10 +461,10 @@ APP_ERROR TrainStepOneEngine::Process()
SetTargetType(postSubData); SetTargetType(postSubData);
pPostData->vecPostSubData.emplace_back(postSubData); pPostData->vecPostSubData.emplace_back(postSubData);
// LogDebug << "数据源:" << pProcessData->iDataSource << " 帧:" << pProcessData->iFrameId LogDebug << "sourceid:" << pProcessData->iDataSource << " frameId:" << pProcessData->iFrameId
// << " --iClassId:" << singledata.iClassId << " iLine:" << singledata.iLine << " confidence=" << singledata.fScore << " --iClassId:" << singledata.iClassId << " iLine:" << singledata.iLine << " confidence=" << singledata.fScore
// << " lx=" << singledata.fLTX << " ly=" << singledata.fLTY << " rx=" << singledata.fRBX << " ry=" << singledata.fRBY << " lx=" << singledata.fLTX << " ly=" << singledata.fLTY << " rx=" << singledata.fRBX << " ry=" << singledata.fRBY
// << " clear:" << singledata.fClear; << " clear:" << singledata.fClear;
} }
} }
} }

8
nvidia_ascend_engine/nvidia_engine/TrainStepTwoEngine/TrainStepTwoEngine.cpp
View File

@ -193,7 +193,7 @@ APP_ERROR TrainStepTwoEngine::Process()
auto start = std::chrono::system_clock::now(); // 计时开始 auto start = std::chrono::system_clock::now(); // 计时开始
yolov5model.YoloV5ClearityInferenceModel(step2_image, res); yolov5model.YoloV5ClearityInferenceModel(step2_image, res);
auto end = std::chrono::system_clock::now(); auto end = std::chrono::system_clock::now();
// LogInfo << "nopr2 inference time: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms"; LogInfo << "nopr2 inference time: " << std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count() << "ms";
PostSubData postSubDataNew; PostSubData postSubDataNew;
postSubDataNew.iTargetType = postsubdata.iTargetType; postSubDataNew.iTargetType = postsubdata.iTargetType;
@ -221,9 +221,9 @@ APP_ERROR TrainStepTwoEngine::Process()
postSubDataNew.vecSingleData.emplace_back(singledata); postSubDataNew.vecSingleData.emplace_back(singledata);
// LogDebug << "sourceid:" << pProcessData->iDataSource << " step2 after frameId:" << pProcessData->iFrameId LogDebug << "sourceid:" << pProcessData->iDataSource << " step2 after frameId:" << pProcessData->iFrameId
// << " --iClassId:" << singledata.iClassId << " iLine:" << singledata.iLine << " confidence=" << singledata.fScore << " --iClassId:" << singledata.iClassId << " iLine:" << singledata.iLine << " confidence=" << singledata.fScore
// << " lx=" << singledata.fLTX << " ly=" << singledata.fLTY << " rx=" << singledata.fRBX << " ry=" << singledata.fRBY; << " lx=" << singledata.fLTX << " ly=" << singledata.fLTY << " rx=" << singledata.fRBX << " ry=" << singledata.fRBY;
} }
pPostData->vecPostSubData.emplace_back(postSubDataNew); pPostData->vecPostSubData.emplace_back(postSubDataNew);
} }

8
nvidia_ascend_tools/nvidia_tools/yolov5/src/preprocess.cu
View File

@ -464,12 +464,12 @@ void yolov5_preprocess_kernel_img(
s2d.value[0] = scale; s2d.value[0] = scale;
s2d.value[1] = 0; s2d.value[1] = 0;
// s2d.value[2] = 0; //左上顶点贴图 s2d.value[2] = 0; //左上顶点贴图
s2d.value[2] = -scale * src_width * 0.5 + dst_width * 0.5; //中心贴图 // s2d.value[2] = -scale * src_width * 0.5 + dst_width * 0.5; //中心贴图
s2d.value[3] = 0; s2d.value[3] = 0;
s2d.value[4] = scale; s2d.value[4] = scale;
// s2d.value[5] = 0; //左上顶点贴图 s2d.value[5] = 0; //左上顶点贴图
s2d.value[5] = -scale * src_height * 0.5 + dst_height * 0.5; //中心贴图 // s2d.value[5] = -scale * src_height * 0.5 + dst_height * 0.5; //中心贴图
cv::Mat m2x3_s2d(2, 3, CV_32F, s2d.value); cv::Mat m2x3_s2d(2, 3, CV_32F, s2d.value);
cv::Mat m2x3_d2s(2, 3, CV_32F, d2s.value); cv::Mat m2x3_d2s(2, 3, CV_32F, d2s.value);