C++调python程序示例

背景

平台：Xavier nvidia AGX板子
编写c++程序测试单目3D目标检测DEVIANT（https://blog.csdn.net/qq_39523365/article/details/130982966?spm=1001.2014.3001.5501）python算法的过程。代码如下：

文件结构

具体代码：

test.cpp

#include <opencv2/opencv.hpp>
#include <iostream>
#include <time.h>
#include "LD_Detection.h"
#include <torch/torch.h>
#include <sys/timeb.h>


LD_Detection *  InitDetection(int m_ichannel, int m_iWidth, int m_iHeight) {
    // 程序执行路径
    std::string application_dir = "/home/nvidia/sd/DEVIANT";
    // qDebug() << "current path: " << qApp->applicationDirPath() << endl;
    application_dir += "/code/tools/";
    const char *m_cPyDir        = application_dir.c_str();
    std::string m_cPyFile       = "demo_inference_zs";
    std::string m_cPyFunction   = "detect_online";
    LD_Detection * m_pLD_Detection = new LD_Detection(m_ichannel, m_iWidth, m_iHeight, m_cPyDir, m_cPyFile.c_str(), m_cPyFunction.c_str() );
    std::cout << "*****************" << std::endl;
	return m_pLD_Detection;
}




int main()
{
	printf("##########%d***",torch::cuda::is_available());
	// 用 OpenCV 打开摄像头读取文件（你随便咋样获取图片都OK哪）
	//cv::VideoCapture cap = cv::VideoCapture(0);
	cv::VideoCapture cap;
	cap.open("/home/nvidia/sd/128G/test/data/video/0320/result2.avi");
	// 设置宽高 无所谓多宽多高后面都会通过一个算法转换为固定宽高的
	// 固定宽高值应该是你通过YoloV5训练得到的模型所需要的
	// 传入方式是构造 YoloV5 对象时传入 width 默认值为 640，height 默认值为 640
	cap.set(cv::CAP_PROP_FRAME_WIDTH, 1920);
	cap.set(cv::CAP_PROP_FRAME_HEIGHT, 1080);

	std::string videoname = "/home/nvidia/sd/128G/test/data/video/0320/result.avi";
	int videoFps = cap.get(cv::CAP_PROP_FPS);
	int myFourCC = cv::VideoWriter::fourcc('m', 'p', '4', 'v');
	cv::VideoWriter g_writer = cv::VideoWriter(videoname, myFourCC, videoFps, cv::Size(cap.get(cv::CAP_PROP_FRAME_WIDTH), cap.get(cv::CAP_PROP_FRAME_HEIGHT)));
	LD_Detection * m_pLD_Detection = InitDetection(0,1920,1080);
	// sleep(5);
	cv::Mat frame;
	int count = 0;
	while (cap.isOpened())
	{
		// 读取一帧
		cap.read(frame);
		if (frame.empty())
		{
			std::cout << "Read frame failed!" << std::endl;
			break;
		}

		std::cout << "------------------------" << std::endl;

		// 预测
		// 简单吧，两行代码预测结果就出来了，封装的还可以吧 嘚瑟
		clock_t start = clock();
		//void LD_Detection::startDetect(int camChan, unsigned char *image)
		m_pLD_Detection->startDetect(count, frame.data);
		clock_t ends = clock();
		// std::cout << start << std::endl;
		// std::cout << ends << std::endl;
		std::cout <<"Running Time : "<<(double)(ends - start) / CLOCKS_PER_SEC << CLOCKS_PER_SEC << std::endl;
		// show 图片
		g_writer << frame;
		// if(count++ > 2000)
		// {
		// 	break;
		// }
		//cv::imshow("", frame);
		//if (cv::waitKey(1) == 27) break;
	}
	g_writer.release();
	return 0;
}

LD_Detection.cpp

// #include <numpy/arrayobject.h>
#include </home/nvidia/sd/miniforge-pypy3/envs/centerpoint/include/python3.6m/Python.h>
#include </home/nvidia/sd/miniforge-pypy3/envs/centerpoint/lib/python3.6/site-packages/numpy/core/include/numpy/arrayobject.h>
// #include </usr/include/python2.7/Python.h>
// #include </usr/lib/python2.7/dist-packages/numpy/core/include/numpy/arrayobject.h>

//#include <json.h>
//#include <writer.h>
//#include <reader.h>
//#include <value.h>
#include "LD_Detection.h"
#include <thread>

// #include <QPainter>
// #include <QThread>

PyObject *pModule = nullptr;
PyObject *pDict = nullptr;
PyObject *pFunc = nullptr;
PyObject *pFunc1 = nullptr;
// PyObject *pFuncrelease = nullptr;
PyThreadState *pyThreadState = nullptr;

// LD_Detection::LD_Detection(QObject *parent, int camCount, int width, int
// height, const char *pyDir, const char *pyFile, const char *pyFunction) :
// QObject(parent)
// {
//     // Python脚本所在路径（绝对路径）
//     m_cPyDir = pyDir;
//     // Python脚本文件名
//     m_cPyFile = pyFile;
//     // Python脚本中要运行的函数名
//     m_cPyFunction = pyFunction;
//
//     m_iCamCount = camCount;
//     m_iCamWidth = width;
//     m_iCamHeight = height;
//     InitPython();
//     ImportPyModule();
//     m_bDetection = false;
//
//     m_pDetectionthread = nullptr;
// }

LD_Detection::LD_Detection(int camChan, int width, int height,
                           const char *pyDir, const char *pyFile,
                           const char *pyFunction) {
  // Python脚本所在路径（绝对路径）
  m_cPyDir = pyDir;
  // Python脚本文件名
  m_cPyFile = pyFile;
  // Python脚本中要运行的函数名
  m_cPyFunction = pyFunction;
  m_iCamChan = camChan;
  m_iCamWidth = width;
  m_iCamHeight = height;
  InitPython();
  ImportPyModule();
  m_bDetection = false;
  std::cout  << m_iCamWidth <<"-----startDetect----- " <<m_iCamHeight << std::endl;
  // std::string videoname = "/Leador_storage/zs/result/result.avi";
  // int myFourCC = cv::VideoWriter::fourcc('m', 'p', '4', 'v');
  // g_writer = cv::VideoWriter(videoname, myFourCC, 20, cv::Size(m_iCamWidth, m_iCamHeight));

}

LD_Detection::~LD_Detection() { 
  ReleasePython();
  // g_writer.release(); 
  }

bool LD_Detection::InitPython() {
  // qDebug() << "-----Initialize Python-----" << endl;
  Py_Initialize();
  if (!Py_IsInitialized()) {
    // qDebug() << "【error】: Python is not initialized" << endl;
    std::cout << "Python is not initialized";

    return false;
  }
  PyEval_InitThreads();
  PyRun_SimpleString("import sys");
  PyRun_SimpleString("print(sys.version)");
  PyRun_SimpleString("print(sys.executable)");
  std::cout << "-----------000-------------" << std::endl;
  
  std::cout << "-----------111-------------" << std::endl;
  import_array();
  std::cout << "-----------222-------------" << std::endl;
  if (PyErr_Occurred()) {
    std::cerr << "【error】: Failed to import numpy Python module" << std::endl;
    return false;
  }
  assert(PyArray_API);
  pyThreadState = PyEval_SaveThread();
  return true;
}

bool LD_Detection::ReleasePython() {
  // PyObject_CallObject(pFuncrelease, NULL);
  PyEval_RestoreThread(pyThreadState);
  Py_DECREF(pModule);
  Py_DECREF(pDict);
  Py_DECREF(pFunc);
  Py_DECREF(pFunc1);
  Py_Finalize();
  return true;
}

void LD_Detection::ImportPyModule() {
  PyGILState_STATE state = PyGILState_Ensure();
  // qDebug() << "-----Add python file path-----" << endl;
  std::cout << "-----Add python file path-----" << m_cPyDir << std::endl;

  char tempPath[256] = {};
  PyRun_SimpleString("import sys");
  sprintf(tempPath, "sys.path.append('%s')", m_cPyDir);
  PyRun_SimpleString(tempPath);
  PyRun_SimpleString("print('curr sys.path: ', sys.path)");
  PyRun_SimpleString("print(sys.version)");
  PyRun_SimpleString("print(sys.executable)");

  std::cout  << "PyRun_SimpleString " << tempPath << std::endl;
  // qDebug() << "-----Add python file-----" << endl;
  std::cout  << "-----Add python file----- " << m_cPyFile << std::endl;
  pModule = PyImport_ImportModule(m_cPyFile);
  std::cout  << "-----Add zs file----- " << m_cPyFile << std::endl;
  if (!pModule) {
    // qDebug() << "【error】: Can't find python file" << endl;
    std::cout  << "-----Can't find python file-----" << m_cPyFile << std::endl;
    return;
  }

  pDict = PyModule_GetDict(pModule);
  if (!pDict) {
    return;
  }

  // qDebug() << "-----Get python function-----" << endl;
  std::cout  << "-----Get python function----- "
               << " pModule " << pModule << " m_cPyFunction " << m_cPyFunction<< endl;
  pFunc1 = PyObject_GetAttrString(pModule, "print_version");
  PyObject *pValue_result =  PyObject_CallObject(pFunc1, NULL);
  int result = PyLong_AsLong(pValue_result);
  std::cout  << "-----zssssssss----- " << result << endl;

  // pFuncrelease = PyObject_GetAttrString(pModule, "release_resource");

  pFunc = PyObject_GetAttrString(pModule, m_cPyFunction);
  // pFunc = PyObject_GetAttrString(pModule, "detect_online");
  // PyObject_CallObject(pFunc, NULL);


  std::cout  << "-----Add python function-----"<< m_cPyFunction << endl;
  if (!pFunc || !PyCallable_Check(pFunc)) {
    // qDebug() << "【error】: Can't find python function" << endl;
    std::cout  << "-----Can't find python function----- " << pFunc;
    return;
  }
  PyGILState_Release(state);
}

void LD_Detection::slotStartDetection() {

  m_bDetection = true;
  //开启推流线程
  m_pDetectionthread =
      new std::thread(&LD_Detection::StartDetectionSingle, this);
}

void LD_Detection::slotStopDetection() {
  m_bDetection = false;
  if (m_pDetectionthread != nullptr) {
    m_pDetectionthread->join();
    delete m_pDetectionthread;
    m_pDetectionthread = nullptr;
  }
}

void LD_Detection::setParam(int nChan, unsigned char *image) {
  m_iChan = nChan;
  m_VideoOrgImage = image;
}

void LD_Detection::setParamMulti(unsigned char *images[]) {
  for (int i = 0; i < m_iCamCount; i++) {
    m_VideoOrgImages[i] = images[i];
  }
}

// 直接传单个图像参数进行检测
void LD_Detection::startDetect(int camChan, unsigned char *image) {
  PyGILState_STATE state = PyGILState_Ensure();
  PyObject *pArgs = PyTuple_New(2);
  cv::Mat temp = cv::Mat(m_iCamHeight, m_iCamWidth, CV_8UC3, image, 0);
  // std::cout  << "-----startDetect----- " << m_iCamWidth << std::endl;
  npy_intp Dims[3] = {temp.rows, temp.cols, temp.channels()};
  PyObject *image_channel = Py_BuildValue("i", camChan);
  PyObject *image_array =
      PyArray_SimpleNewFromData(3, Dims, NPY_UBYTE, temp.data);
  PyTuple_SetItem(pArgs, 0, image_channel);
  PyTuple_SetItem(pArgs, 1, image_array);
  PyObject *pReturnValue = PyObject_CallObject(pFunc, pArgs);
  // std::cout  << "-----startDetect----- " << m_iCamWidth << std::endl;
  if (PyList_Check(pReturnValue)) {
    int SizeOfObjects = PyList_Size(pReturnValue);
    std::cout  << "Size of return list: " << SizeOfObjects << std::endl;
    sign_objects.clear();
    for (int i = 0; i < SizeOfObjects; i++) {
      PyObject *pObject = PyList_GetItem(pReturnValue, i);
      int SizeOfObject = PyList_Size(pObject);
      std::cout  << "Size of return sublist: " << SizeOfObject << std::endl;

      struct SignObject object;
      PyArg_Parse(PyList_GetItem(pObject, 2), "f", &object.x_min);
      PyArg_Parse(PyList_GetItem(pObject, 3), "f", &object.y_min);
      PyArg_Parse(PyList_GetItem(pObject, 4), "f", &object.x_max);
      PyArg_Parse(PyList_GetItem(pObject, 5), "f", &object.y_max);
      PyArg_Parse(PyList_GetItem(pObject, 13), "f", &object.confidence);
      PyArg_Parse(PyList_GetItem(pObject, 0), "i", &object.clas);
      // PyArg_Parse(PyList_GetItem(pObject, 6), "s", &object.clas_name);
      std::cout  << "Object's x_min: " << object.x_min << std::endl;
      std::cout  << "Object's y_min: " << object.y_min << std::endl;
      std::cout  << "Object's x_max: " << object.x_max << std::endl;
      std::cout  << "Object's y_max: " << object.y_max << std::endl;
      std::cout  << "Object's confidence: " << object.confidence << std::endl;
      std::cout  << "Object's class name: " << object.clas << std::endl;
      sign_objects.push_back(object);

      cv::Point point_min((int)object.x_min, (int)object.y_min),
          point_max((int)object.x_max, (int)object.y_max);
      cv::Scalar colorRectangle(255, 0, 0);
      int thicknessRectangle = 3;
      cv::resize(temp,temp, cv::Size(768, 512));
      cv::rectangle(temp, point_min, point_max, colorRectangle,
      thicknessRectangle);
      
      cv::imwrite("test.jpg", temp);
      // cv::imshow("test", temp);
      // g_writer<<temp;
    }
  }
  PyGILState_Release(state);
}

// 直接传多个图像参数进行检测
void LD_Detection::startDetection(unsigned char *images[]) {
  PyGILState_STATE state = PyGILState_Ensure();
  PyObject *pArgImages = PyTuple_New(m_iCamChan);
  for (int i = 0; i < m_iCamChan; i++) {
    cv::Mat temp = cv::Mat(m_iCamHeight, m_iCamWidth, CV_8UC3, images[i], 0);
    npy_intp Dims[3] = {temp.rows, temp.cols, temp.channels()};
    PyObject *image_array =
        PyArray_SimpleNewFromData(3, Dims, NPY_UBYTE, temp.data);
    PyTuple_SetItem(pArgImages, i, image_array);
  }
  PyObject *pArgs = PyTuple_New(1);
  PyTuple_SetItem(pArgs, 0, pArgImages);
  PyObject_CallObject(pFunc, pArgs);

  PyGILState_Release(state);

  // QThread::msleep(1);
}

// Muilt Camera detection
void LD_Detection::StartDetectionMulti() {
  // qDebug() << "-----Video data to python function-----" << endl;
  while (m_bDetection) {
    PyGILState_STATE state = PyGILState_Ensure();
    PyObject *pArgImages = PyTuple_New(m_iCamCount);
    for (int i = 0; i < m_iCamCount; i++) {
      cv::Mat temp =
          cv::Mat(m_iCamHeight, m_iCamWidth, CV_8UC3, m_VideoOrgImages[i], 0);
      npy_intp Dims[3] = {temp.rows, temp.cols, temp.channels()};
      PyObject *image_array =
          PyArray_SimpleNewFromData(3, Dims, NPY_UBYTE, temp.data);
      PyTuple_SetItem(pArgImages, i, image_array);
    }
    PyObject *pArgs = PyTuple_New(1);
    PyTuple_SetItem(pArgs, 0, pArgImages);
    PyObject_CallObject(pFunc, pArgs);

    PyGILState_Release(state);

    // QThread::msleep(1);
    std::chrono::milliseconds dura(2);
    std::this_thread::sleep_for(dura);
  }
}

// Single Camera detection
void LD_Detection::StartDetectionSingle() {
  // qDebug() << "-----Video data to python function-----" << endl;
  int count = 0;
  while (m_bDetection) {
    PyGILState_STATE state = PyGILState_Ensure();
    PyObject *pArgs = PyTuple_New(2);
    PyObject *pReturnValue;
    cv::Mat temp =
        cv::Mat(m_iCamHeight, m_iCamWidth, CV_8UC3, m_VideoOrgImage, 0);
    //        qDebug() << "CVImage exist: " << temp.empty() << endl;
    //        cv::cvtColor(temp, *image, cv::COLOR_BGR2RGB);
    //        QString title = QString("test%1").arg(m_iChan);
    //        cv::imshow(title.toStdString(), *image);
    npy_intp Dims[3] = {temp.rows, temp.cols, temp.channels()};
    PyObject *image_channel = Py_BuildValue("i", count);
    PyObject *image_array =
        PyArray_SimpleNewFromData(3, Dims, NPY_UBYTE, temp.data);
    PyTuple_SetItem(pArgs, 0, image_channel);
    PyTuple_SetItem(pArgs, 1, image_array);
    // PyObject_CallObject(pFunc, pArgs);

    pReturnValue = PyObject_CallObject(pFunc, pArgs);

    if (PyList_Check(pReturnValue)) {
      int SizeOfObjects = PyList_Size(pReturnValue);
      // qDebug() << "Size of return list" << SizeOfObjects << endl;
      sign_objects.clear();
      for (int i = 0; i < SizeOfObjects; i++) {
        PyObject *pObject = PyList_GetItem(pReturnValue, i);
        int SizeOfObject = PyList_Size(pObject);

        //                for(int j = 0; j < pObject; j ++)
        //                {
        //                    float item = 0.0;
        //                    PyObject *pItem = PyList_GetItem(pObject, j);
        //                    PyArg_Parse(pItem, "f", &item);
        //                    qDebug() << "Data: " << item << " ";
        //                }
        struct SignObject object;
        PyArg_Parse(PyList_GetItem(pObject, 0), "i", &object.x_min);
        PyArg_Parse(PyList_GetItem(pObject, 1), "i", &object.y_min);
        PyArg_Parse(PyList_GetItem(pObject, 2), "i", &object.x_max);
        PyArg_Parse(PyList_GetItem(pObject, 3), "i", &object.y_max);
        PyArg_Parse(PyList_GetItem(pObject, 4), "f", &object.confidence);
        PyArg_Parse(PyList_GetItem(pObject, 5), "i", &object.clas);
        PyArg_Parse(PyList_GetItem(pObject, 6), "s", &object.clas_name);
        // qDebug() << "Object's x_min: " << object.x_min;
        // qDebug() << "Object's y_min: " << object.y_min;
        // qDebug() << "Object's x_max: " << object.x_max;
        // qDebug() << "Object's y_max: " << object.y_max;
        // qDebug() << "Object's confidence: " << object.confidence;
        // qDebug() << "Object's class name: " << object.clas_name;
        sign_objects.push_back(object);

        cv::Point point_min(object.x_min, object.y_min),
            point_max(object.x_max, object.y_max);
        cv::Scalar colorRectangle(255, 0, 0);
        int thicknessRectangle = 3;

        cv::rectangle(temp, point_min, point_max, colorRectangle,
                      thicknessRectangle);
      }
      // QString title = QString("test%1").arg(m_iChan);
      //            cv::imshow(title.toStdString(), temp);

      // qDebug() << "Number of objects in cur image: " << sign_objects.size()
      // << endl;
    }

    count++;
    PyGILState_Release(state);

    // QThread::msleep(1);
    std::chrono::milliseconds dura(1);
    std::this_thread::sleep_for(dura);
  }
}

LD_Detection.h

#ifndef LD_DETECTION_H
#define LD_DETECTION_H

#include <iostream>
// #include <QObject>
// #include <QDebug>
// #include <QImage>
// #include <QVector>
#include <opencv2/highgui.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/opencv.hpp>
#include <thread>
#include <numpy/arrayobject.h>

#define MAX_CAMER_NUM 8

using namespace std;

class LD_Detection {
public:
  struct SignObject {
    float x_min;
    float y_min;
    float x_max;
    float y_max;
    float confidence;
    int clas;
    char *clas_name;
  };

  std::vector<SignObject> sign_objects;

public:
  // LD_Detection(int camCount, int width, int height, const char *pyDir,
  //              const char *pyFile, const char *pyFunction);
  LD_Detection(int camChan, int width, int height, const char *pyDir,
               const char *pyFile, const char *pyFunction);
  ~LD_Detection();

  void setParam(int nChan, unsigned char *image);
  void setParamMulti(unsigned char *images[]);
  void startDetect(int camChan, unsigned char *image);
  void startDetection(unsigned char *images[]);
  void StartDetectionSingle();
  void StartDetectionMulti();

  void RunDetection(bool bDetection);

private:
  bool InitPython();
  bool ReleasePython();
  void ImportPyModule();

private:
  int m_iCamChan = 0;
  int m_iCamCount = 0;
  int m_iCamWidth = 0;
  int m_iCamHeight = 0;
  const char *m_cPyDir;
  const char *m_cPyFile;
  const char *m_cPyFunction;
  unsigned char *m_VideoOrgImage;
  unsigned char *m_VideoOrgImages[MAX_CAMER_NUM];
  int m_iChan = 0;

  std::thread *m_pDetectionthread;
  bool m_bDetection;

  cv::VideoWriter g_writer;

  void slotStartDetection();
  void slotStopDetection();
};

#endif // LD_DETECTION_H

CMakeLists.txt

#1.cmake verson，指定cmake版本 
cmake_minimum_required(VERSION 3.2)

#2.project name，指定项目的名称，一般和项目的文件夹名称对应
PROJECT(TEST)

option(USE_PYTORCH " set ON detection mode change to USE_PYTORCH" ON)
option(NO_Encrtyption " set ON 测试模式，不需要license，且模型是未加密的模型" OFF)

set(op_cnt 0)
if (USE_PYTORCH)
    math(EXPR op_cnt ${op_cnt}+1)
    message("Using RefineDet detection 2")
endif()


#3.head file path，头文件目录
INCLUDE_DIRECTORIES(
    ${CMAKE_CURRENT_SOURCE_DIR}
    ${CMAKE_CURRENT_SOURCE_DIR}/include
)
#set(OpenCV_DIR /usr/local/share/OpenCV)
find_package (OpenCV REQUIRED NO_CMAKE_FIND_ROOT_PATH)
if(OpenCV_FOUND)
    INCLUDE_DIRECTORIES(${OpenCV_INCLUDE_DIRS})
    message(STATUS "OpenCV library status:")
    message(STATUS "    version: ${OpenCV_VERSION}")
    message(STATUS "    libraries: ${OpenCV_LIBS}")
    message(STATUS "    include path: ${OpenCV_INCLUDE_DIRS}")
endif()

if(USE_PYTORCH)
    IF(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "aarch64")
        MESSAGE(STATUS "Now is aarch64 OS's.")
        #Set library path
        set(CMAKE_PREFIX_PATH /home/nvidia/sd/miniforge-pypy3/envs/centerpoint/lib/python3.6/site-packages/torch)
    ELSE()
        MESSAGE(STATUS "Now is UNIX-like PC OS's.")
        #Set library path
        #set(CMAKE_PREFIX_PATH /home/he/miniconda/envs/py36/lib/python3.6/site-packages/torch)
        #set(TensorRT_DIR /home/he/work/TensorRT/tensorrt_v5.1_x64_release)
        #if(DEFINED TensorRT_DIR)
        #    include_directories("${TensorRT_DIR}/include" )
        #    link_directories("${TensorRT_DIR}/lib")
        #    link_directories("/usr/local/cuda/lib64")
        #endif(DEFINED TensorRT_DIR)
    ENDIF()
endif()


message("${ALGORITHM_SDK_INCLUDE_DIR}")

find_package (Torch REQUIRED NO_CMAKE_FIND_ROOT_PATH)


#4.source directory，APP源文件目录
#AUX_SOURCE_DIRECTORY(libosa/src DIR_SRCS)
AUX_SOURCE_DIRECTORY(src DIR_SRCS)

AUX_SOURCE_DIRECTORY(test TEST_SRCS)

SET(CMAKE_BUILD_TYPE RELEASE) #DEBUG RELEASE
#设置编译器版本
SET(CMAKE_C_COMPILER gcc)
SET(CMAKE_CXX_COMPILER g++)
if(CMAKE_COMPILER_IS_GNUCXX)
    #add_compile_options(-std=c++11)
    #message(STATUS "optional:-std=c++11")
endif(CMAKE_COMPILER_IS_GNUCXX)


#5.set environment variable，置环境变量，编译用到的源文件全部都要放到这里，否则编译能够通过，但是执行的时候会出现各种问题
SET(PROC_ALL_FILES
${DIR_SRCS}
)

set(TEST_APP Test_app)
# cuda
include_directories("/usr/local/cuda/include"
    /home/nvidia/sd/miniforge-pypy3/envs/centerpoint/include/python3.6m
    /home/nvidia/sd/miniforge-pypy3/envs/centerpoint/lib/python3.6/site-packages/numpy/core/include/numpy
    )
link_directories("/usr/local/cuda/lib64")
link_directories(BEFORE "/home/nvidia/sd/miniforge-pypy3/envs/centerpoint/lib")
link_directories(BEFORE "/home/nvidia/sd/miniforge-pypy3/envs/centerpoint/lib/python3.6/site-packages/numpy/core")
link_directories(BEFORE "/home/nvidia/sd/miniforge-pypy3/envs/centerpoint/lib/python3.6/config-3.6m-aarch64-linux-gnu")

#6.add executable file，添加要编译的可执行文件
#ADD_EXECUTABLE(${PROJECT_NAME} ${PROC_ALL_FILES})    #编译成可执行文件
add_library(${PROJECT_NAME} SHARED ${PROC_ALL_FILES}) #编译成动态库
add_executable(${TEST_APP} ${TEST_SRCS})

FILE(GLOB_RECURSE LIBS_CUDA /usr/local/cuda/lib64)
FILE(GLOB_RECURSE LIBS_BOOST_SYS /usr/lib/x86_64-linux-gnu/libboost_system.so)

#7.add link library，添加可执行文件所需要的库，比如我们用到了libm.so（命名规则：lib+name+.so），就添加该库的名称
TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${OpenCV_LIBS})
TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${TORCH_LIBRARIES} pthread)
TARGET_LINK_LIBRARIES(${PROJECT_NAME} -ldl  -lcudart -lcublas -lcurand -lcudnn)

TARGET_LINK_LIBRARIES(${TEST_APP} ${OpenCV_LIBS})
TARGET_LINK_LIBRARIES(${TEST_APP} ${TORCH_LIBRARIES} pthread)
TARGET_LINK_LIBRARIES(${TEST_APP} ${PROJECT_NAME} )
#TARGET_LINK_LIBRARIES(${TEST_APP} -ldl)
TARGET_LINK_LIBRARIES(${TEST_APP} -ldl /home/nvidia/sd/miniforge-pypy3/envs/centerpoint/lib/libpython3.6m.so)

1.txt

export LD_LIBRARY_PATH=/home/nvidia/sd/miniforge-pypy3/envs/centerpoint/lib:/home/nvidia/sd/miniforge-pypy3/envs/centerpoint/lib/python3.6/site-packages/numpy/core:/home/nvidia/sd/miniforge-pypy3/envs/centerpoint/lib/python3.6/config-3.6m-aarch64-linux-gnu:$LD_LIBRARY_PATH
nvidia的torch cuda要确认
link_directories是编译代码所需要链接的库，不包含链接库又链接的库，链接库又链接的库找的不对时，可以用LD_LIBRARY_PATH指定程序执行时链接的路径；LD_LIBRARY_PATH是程序运行时曲查找链接库的路径。

1.gdb ./TeTest_app; 2.r; 3.where/bt
ros代码软件路径被修改后，需要重新catkin_make编译一下，具体可以运行命令“catkin_make clean”，或者将build和devel文件夹删除。
    ros::Publisher pub_Monocular_result;
    pub_Monocular_result =nh_.advertise<gmsl_pub::Detection_result>( "/Detection_result", 1 );

    gmsl_pub::Detection_result image_resultMsg;
    image_resultMsg.header.stamp    = ros::Time::now();
    image_resultMsg.header.frame_id = "camera_2";
    uint32 size = ;                   //size代表检测目标的个数
    uint32 origin_flag  = 2;            //origin_flag代表检测算法来源
    gmsl_pub::Object_result[] ob_result = ;     //代表object_result.msg的数组

    pub_Monocular_result.publish( image_resultMsg );

调用的python文件如下：

demo_inference_zs.py

import os
import sys
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
ROOT_DIR = os.path.dirname(BASE_DIR)
sys.path.append(ROOT_DIR)
sys.path.append('/home/nvidia/sd/DEVIANT/code/tools')
sys.path.append('/home/nvidia/sd/miniforge-pypy3/envs/centerpoint/lib/python3.6/site-packages')
import yaml
import logging
import argparse
import numpy as np
print(np.__path__)
import torch
import time
import random

from lib.helpers.dataloader_helper import build_dataloader
from lib.helpers.model_helper import build_model
from lib.helpers.optimizer_helper import build_optimizer
from lib.helpers.scheduler_helper import build_lr_scheduler
from lib.helpers.trainer_helper import Trainer
from lib.helpers.tester_helper import Tester
from lib.datasets.kitti_utils import get_affine_transform
from lib.datasets.kitti_utils import Calibration
from lib.datasets.kitti_utils import compute_box_3d
from lib.datasets.waymo import affine_transform

from lib.helpers.save_helper import load_checkpoint
from lib.helpers.decode_helper import extract_dets_from_outputs
from lib.helpers.decode_helper import decode_detections
from lib.helpers.rpn_util import *

from datetime import datetime

sys.path.append('%s')
sys.path.append('%s')


def print_version():
    print(torch.__version__)
    print(torch.__path__)
    return 100

def create_logger(log_file):
    log_format = '%(asctime)s  %(levelname)5s  %(message)s'
    logging.basicConfig(level=logging.INFO, format=log_format, filename=log_file)
    console = logging.StreamHandler()
    console.setLevel(logging.INFO)
    console.setFormatter(logging.Formatter(log_format))
    logging.getLogger().addHandler(console)
    return logging.getLogger(__name__)

def init_torch(rng_seed, cuda_seed):
    """
    Initializes the seeds for ALL potential randomness, including torch, numpy, and random packages.

    Args:
        rng_seed (int): the shared random seed to use for numpy and random
        cuda_seed (int): the random seed to use for pytorch's torch.cuda.manual_seed_all function
    """
    # seed everything
    os.environ['PYTHONHASHSEED'] = str(rng_seed)
    torch.manual_seed(rng_seed)
    np.random.seed(rng_seed)
    random.seed(rng_seed)
    torch.cuda.manual_seed(cuda_seed)
    torch.cuda.manual_seed_all(cuda_seed)

    # make the code deterministic
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False

def pretty_print(name, input, val_width=40, key_width=0):
    """
    This function creates a formatted string from a given dictionary input.
    It may not support all data types, but can probably be extended.

    Args:
        name (str): name of the variable root
        input (dict): dictionary to print
        val_width (int): the width of the right hand side values
        key_width (int): the minimum key width, (always auto-defaults to the longest key!)

    Example:
        pretty_str = pretty_print('conf', conf.__dict__)
        pretty_str = pretty_print('conf', {'key1': 'example', 'key2': [1,2,3,4,5], 'key3': np.random.rand(4,4)})

        print(pretty_str)
        or
        logging.info(pretty_str)
    """
    pretty_str = name + ': {\n'
    for key in input.keys(): key_width = max(key_width, len(str(key)) + 4)

    for key in input.keys():
        val = input[key]
        # round values to 3 decimals..
        if type(val) == np.ndarray: val = np.round(val, 3).tolist()
        # difficult formatting
        val_str = str(val)
        if len(val_str) > val_width:
            # val_str = pprint.pformat(val, width=val_width, compact=True)
            val_str = val_str.replace('\n', '\n{tab}')
            tab = ('{0:' + str(4 + key_width) + '}').format('')
            val_str = val_str.replace('{tab}', tab)
        # more difficult formatting
        format_str = '{0:' + str(4) + '}{1:' + str(key_width) + '} {2:' + str(val_width) + '}\n'
        pretty_str += format_str.format('', key + ':', val_str)

    # close root object
    pretty_str += '}'
    return pretty_str
def np2tuple(n):
    return (int(n[0]), int(n[1]))

# def main(): 
# load cfg
config = "/home/nvidia/sd/DEVIANT/code/experiments/run_test.yaml"
cfg = yaml.load(open(config, 'r'), Loader=yaml.Loader)
exp_parent_dir = os.path.join(cfg['trainer']['log_dir'], os.path.basename(config).split(".")[0])
cfg['trainer']['log_dir'] = exp_parent_dir
logger_dir     = os.path.join(exp_parent_dir, "log")
os.makedirs(exp_parent_dir, exist_ok=True)
os.makedirs(logger_dir, exist_ok=True)
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
logger = create_logger(os.path.join(logger_dir, timestamp))
pretty = pretty_print('conf', cfg)
logging.info(pretty)
# init torch
init_torch(rng_seed= cfg['random_seed']-3, cuda_seed= cfg['random_seed'])
##w,h,l
# Ped  [1.7431 0.8494 0.911 ]
# Car  [1.8032 2.1036 4.8104]
# Cyc  [1.7336 0.823  1.753 ]
# Sign [0.6523 0.6208 0.1254]
cls_mean_size = np.array([[1.7431, 0.8494, 0.9110],
                                [1.8032, 2.1036, 4.8104],
                                [1.7336, 0.8230, 1.7530],
                                [0.6523, 0.6208, 0.1254]])

# build model
model = build_model(cfg,cls_mean_size)

device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(device)
print(cfg['tester']['resume_model'])
load_checkpoint(model = model,
                optimizer = None,
                filename = cfg['tester']['resume_model'],
                logger=logger,
                map_location= device)
model.to(device)

torch.set_grad_enabled(False)
model.eval()
calibs = np.array([9.5749393532104671e+02/1920.0*768.0*0.9, 0., (1.0143950223349893e+03)/1920.0*768.0, 0., 
0., 9.5697913744394737e+02/1080.0*512.0*0.9, 5.4154074349276050e+02/1080.0*512.0, 0., 
0.0, 0.0, 1.0, 0.], dtype=np.float32)
calibsP2=calibs.reshape(3, 4)
calibs = torch.from_numpy(calibsP2).unsqueeze(0).to(device) 

resolution = np.array([768, 512])
downsample = 4
# coord_ranges = np.array([center-crop_size/2,center+crop_size/2]).astype(np.float32)
coord_ranges = np.array([np.array([0, 0]),resolution]).astype(np.float32)
coord_ranges = torch.from_numpy(coord_ranges).unsqueeze(0).to(device) 
features_size = resolution // downsample

# c++调用的接口
def detect_online(frame_chan, frame):
    print("image channel :", frame_chan)
    img        = frame
    index = np.array([frame_chan])
    #img = img[0:1080, int(150-1):int(1920-150-1)]
    # img = cv2.resize(img, (768, 512))
    img_cv_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
    img    = Image.fromarray(img_cv_rgb)
    img_size = np.array(img.size)
    center = img_size / 2
    crop_size = img_size

    info = {'img_id': index,
            'img_size': resolution,
            'bbox_downsample_ratio': resolution / features_size}

    # add affine transformation for 2d images.
    trans, trans_inv = get_affine_transform(center, crop_size, 0, resolution, inv=1)
    img = img.transform(tuple(resolution.tolist()),
                        method=Image.AFFINE,
                        data=tuple(trans_inv.reshape(-1).tolist()),
                        resample=Image.BILINEAR)
                  
    # image encoding
    img = np.array(img).astype(np.float32) / 255.0
    mean = np.array([0.485, 0.456, 0.406], dtype=np.float32)
    std  = np.array([0.229, 0.224, 0.225], dtype=np.float32)
    img = (img - mean) / std
    img = img.transpose(2, 0, 1)  # C * H * W
    inputs = img

    inputs = torch.from_numpy(inputs)
    inputs = inputs.unsqueeze(0)  
    inputs = inputs.to(device)
    # the outputs of centernet
    outputs = model(inputs,coord_ranges,calibs,K=50,mode='test')
    print(np.__path__)
    dets = extract_dets_from_outputs(outputs=outputs, K=50)
    dets = dets.detach().cpu().numpy()

    calibs1 = Calibration(calibsP2)
    dets = decode_detections(dets = dets,
                                info = info,
                                calibs = calibs1,
                                cls_mean_size=cls_mean_size,
                                threshold = cfg['tester']['threshold'])

    print(dets)
    # img        = cv2.imread(img_file, cv2.IMREAD_COLOR)
    # # img = cv2.resize(img, (768, 512))

    # for i in range(len(dets)):
    #     #cv2.rectangle(img, (int(dets[i][2]), int(dets[i][3])), (int(dets[i][4]), int(dets[i][5])), (0, 0, 255), 1)
    #     corners_2d,corners_3d=compute_box_3d(dets[i][6], dets[i][7], dets[i][8], dets[i][12],
    #      (dets[i][9], dets[i][10], dets[i][11]), calibs)
    #     for i in range(corners_2d.shape[0]):
    #         corners_2d[i] = affine_transform(corners_2d[i], trans_inv)
    #     cv2.line(img,np2tuple(corners_2d[0]),np2tuple(corners_2d[1]),(255,255,0),1,cv2.LINE_4)
    #     cv2.line(img,np2tuple(corners_2d[1]),np2tuple(corners_2d[2]),(255,255,0),1,cv2.LINE_4)
    #     cv2.line(img,np2tuple(corners_2d[2]),np2tuple(corners_2d[3]),(255,255,0),1,cv2.LINE_4)
    #     cv2.line(img,np2tuple(corners_2d[3]),np2tuple(corners_2d[0]),(255,255,0),1,cv2.LINE_4)

    #     cv2.line(img,np2tuple(corners_2d[4]),np2tuple(corners_2d[5]),(255,255,0),1,cv2.LINE_4)
    #     cv2.line(img,np2tuple(corners_2d[5]),np2tuple(corners_2d[6]),(255,255,0),1,cv2.LINE_4)
    #     cv2.line(img,np2tuple(corners_2d[6]),np2tuple(corners_2d[7]),(255,255,0),1,cv2.LINE_4)
    #     cv2.line(img,np2tuple(corners_2d[7]),np2tuple(corners_2d[4]),(255,255,0),1,cv2.LINE_4)

    #     cv2.line(img,np2tuple(corners_2d[5]),np2tuple(corners_2d[1]),(255,255,0),1,cv2.LINE_4)
    #     cv2.line(img,np2tuple(corners_2d[4]),np2tuple(corners_2d[0]),(255,255,0),1,cv2.LINE_4)

    #     cv2.line(img,np2tuple(corners_2d[6]),np2tuple(corners_2d[2]),(255,255,0),1,cv2.LINE_4)
    #     cv2.line(img,np2tuple(corners_2d[7]),np2tuple(corners_2d[3]),(255,255,0),1,cv2.LINE_4)
    # cv2.imwrite("3.jpg", img)
    return dets

if __name__ == '__main__':
    img_file = "./code/tools/img/result2_00000575.jpg"
    frame        = cv2.imread(img_file, cv2.IMREAD_COLOR)
    frame_chan = 0
    detect_online(frame_chan, frame)