海康威视相机-LINUX SDK 开发

news2024/11/27 17:38:22

硬件与环境

mvs

相机： MV-CS020-10GC
系统：UBUNTU 22.04
语言：C++
工具：cmake
海康官网下载SDK
在这里插入图片描述

在这里插入图片描述
运行下面的命令进行安装

sudo dpkg -i  MVSXXX.deb

安装完成后从在/opt/MVS 路径下就有了相关的库，实际上我们开发的时候只需要lib和include。有兴趣的同学也可以尝试以下Samples的例子。make一下就能生成可执行文件。如果make报错，可能环境变量没有设置好，到bin文件夹下把那几个设置环境变量的shell脚本运行一下再试一试。

make

在这里插入图片描述
这里是我运行了/opt/MVS/Samples/64/Display下的例子。

在这里插入图片描述

开发

实际上我们开发的时候只需要目录/opt/MVS/lib和/opt/MVS/include下的文件。他们是海康提供的链接库。所以我们在写程序的时候链接到海康的库，我们就能调用海康官方的接口了。

我将海康的库放在我工程的3rdPartys下，这样就移植到其他电脑上会比较方便。

add_library(
        cameraAPI
        SHARED
)
# Define preprocessor macro for exporting symbols on Windows

if(WIN32)
        target_compile_definitions(cameraAPI PRIVATE cameraAPI_EXPORTS)
endif()


message( target name: cameraAPI )

target_include_directories(
        cameraAPI  PRIVATE
        ${OpenCV_INCLUDE_DIRS}
        ./include
        ./3rdPartys/mvsinclude
)

target_sources(
        cameraAPI PRIVATE
        ./src/edge_camera.cpp
)

target_link_directories(
        cameraAPI  PUBLIC
        ${OpenCV_LIBS}
        ./3rdPartys/mvslib/64
)

target_link_libraries(
        cameraAPI  PRIVATE
        ${OpenCV_LIBS}
        MvCameraControl
        pthread
)

主要的程序

//
// Created by zc on 8/24/23.
//
#include "edge_camera.h"

 EDGE_CAMERA::EDGE_CAMERA() {
    std::cout<<"EDGE_CAMERA BEGIN!"<<std::endl;
}

EDGE_CAMERA::~EDGE_CAMERA(){
    std::cout<<"EDGE_CAMERA FINISH!"<<std::endl;
}


// print the discovered devices' information
void EDGE_CAMERA::PrintDeviceInfo(MV_CC_DEVICE_INFO* pstMVDevInfo)
{
    if (nullptr == pstMVDevInfo)
    {
        printf("    NULL info.\n\n");
        return;
    }

    if (MV_GIGE_DEVICE == pstMVDevInfo->nTLayerType)
    {
        unsigned int nIp1 = ((pstMVDevInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0xff000000) >> 24);
        unsigned int nIp2 = ((pstMVDevInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0x00ff0000) >> 16);
        unsigned int nIp3 = ((pstMVDevInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0x0000ff00) >> 8);
        unsigned int nIp4 = (pstMVDevInfo->SpecialInfo.stGigEInfo.nCurrentIp & 0x000000ff);

        // en:Print current ip and user defined name
        printf("    IP: %d.%d.%d.%d\n" , nIp1, nIp2, nIp3, nIp4);
        printf("    UserDefinedName: %s\n" , pstMVDevInfo->SpecialInfo.stGigEInfo.chUserDefinedName);
        printf("    Device Model Name: %s\n\n", pstMVDevInfo->SpecialInfo.stGigEInfo.chModelName);
    }
    else if (MV_USB_DEVICE == pstMVDevInfo->nTLayerType)
    {
        printf("    UserDefinedName: %s\n", pstMVDevInfo->SpecialInfo.stUsb3VInfo.chUserDefinedName);
        printf("    Device Model Name: %s\n\n", pstMVDevInfo->SpecialInfo.stUsb3VInfo.chModelName);
    }
    else
    {
        printf("    Not support.\n\n");
    }
}


//  en:Convert pixel arrangement from RGB to BGR
void EDGE_CAMERA::RGB2BGR( unsigned char* pRgbData, unsigned int nWidth, unsigned int nHeight )
{
    if ( nullptr == pRgbData )
    {
        return;
    }

    // RGB TO BGR
    for (unsigned int j = 0; j < nHeight; j++)
    {
        for (unsigned int i = 0; i < nWidth; i++)
        {
            unsigned char red = pRgbData[j * (nWidth * 3) + i * 3];
            pRgbData[j * (nWidth * 3) + i * 3]     = pRgbData[j * (nWidth * 3) + i * 3 + 2];
            pRgbData[j * (nWidth * 3) + i * 3 + 2] = red;
        }
    }
}



// en:Convert data stream to Mat format then save image
bool EDGE_CAMERA::Convert2Mat(MV_FRAME_OUT_INFO_EX *pstImageInfo, unsigned char *pData, cv::Mat &img)
{
    if (nullptr == pstImageInfo || nullptr == pData)
    {
        printf("NULL info or data.\n");
        return false;
    }

    cv::Mat srcImage;

    if ( PixelType_Gvsp_Mono8 == pstImageInfo->enPixelType )                // Mono8
    {
        srcImage = cv::Mat(pstImageInfo->nHeight, pstImageInfo->nWidth, CV_8UC1, pData);
    }
    else if ( PixelType_Gvsp_RGB8_Packed == pstImageInfo->enPixelType )     // RGB8
    {
        RGB2BGR(pData, pstImageInfo->nWidth, pstImageInfo->nHeight);
        srcImage = cv::Mat(pstImageInfo->nHeight, pstImageInfo->nWidth, CV_8UC3, pData);
    }
    else if(PixelType_Gvsp_BayerRG8 == pstImageInfo->enPixelType)           // BayerRG8
    {
        printf("pPixelType_Gvsp_BayerRG8 type is converted to Mat\n");
        //RGB2BGR(pData, pstImageInfo->nWidth, pstImageInfo->nHeight);
        srcImage = cv::Mat(pstImageInfo->nHeight, pstImageInfo->nWidth, CV_8UC1, pData);
       // srcImage.create(srcImage.rows,srcImage.cols,CV_8UC3);
        cvtColor(srcImage, srcImage, cv::COLOR_BayerRG2RGB);
    }
    else
    {
        printf("Unsupported pixel format\n");
        return false;
    }

    if ( nullptr == srcImage.data )
    {
        printf("Creat Mat failed.\n");
        return false;
    }

    try
    {
        // en:Save converted image in a local file
        img = srcImage;
        cv::imwrite("Image_Mat.bmp", srcImage);
    }
    catch (cv::Exception& ex)
    {
        fprintf(stderr, "Exception in saving mat image: %s\n", ex.what());
    }

    srcImage.release();

    return true;
}

// en:Convert data stream in Ipl format then save image
bool EDGE_CAMERA::Convert2Ipl(MV_FRAME_OUT_INFO_EX* pstImageInfo, unsigned char * pData)
{
    if (nullptr == pstImageInfo || nullptr == pData)
    {
        printf("NULL info or data.\n");
        return false;
    }

    IplImage* srcImage = nullptr;

    if ( PixelType_Gvsp_Mono8 == pstImageInfo->enPixelType )                // Mono8????
    {
        srcImage = cvCreateImage(cvSize(pstImageInfo->nWidth, pstImageInfo->nHeight), IPL_DEPTH_8U, 1);
    }
    else if ( PixelType_Gvsp_RGB8_Packed == pstImageInfo->enPixelType )     // RGB8????
    {
        RGB2BGR(pData, pstImageInfo->nWidth, pstImageInfo->nHeight);
        srcImage = cvCreateImage(cvSize(pstImageInfo->nWidth, pstImageInfo->nHeight), IPL_DEPTH_8U, 3);
    }
    else
    {
        printf("Unsupported pixel format\n");
        return false;
    }

    if ( nullptr == srcImage )
    {
        printf("Creat IplImage failed.\n");
        return false;
    }

    srcImage->imageData = (char *)pData;

    try
    {
        // en:Save converted image in a local file
        cv::Mat cConvertImage = cv::cvarrToMat(srcImage);
        cv::imwrite("Image_Ipl.bmp", cConvertImage);

        cConvertImage.release();
    }
    catch (cv::Exception& ex)
    {
        fprintf(stderr, "Exception in saving IplImage: %s\n", ex.what());
    }

    cvReleaseImage(&srcImage);

    return true;
}


void EDGE_CAMERA::findCameras(){
    int nRet = MV_OK;
    //void* handle = nullptr;
    //unsigned char * pData = nullptr;
    //MV_CC_DEVICE_INFO_LIST _stDeviceList;
    memset(&_stDeviceList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

    // en:Enum device
    do {
        nRet = MV_CC_EnumDevices(MV_GIGE_DEVICE | MV_USB_DEVICE, &_stDeviceList);
        if (MV_OK != nRet) {
            printf("Enum Devices fail! nRet [0x%x]\n", nRet);
            break;
        }

        // en:Show devices
        if (_stDeviceList.nDeviceNum > 0) {
            for (unsigned int i = 0; i < _stDeviceList.nDeviceNum; i++) {
                printf("[device %d]:\n", i);
                MV_CC_DEVICE_INFO *pDeviceInfo = _stDeviceList.pDeviceInfo[i];
                if (nullptr == pDeviceInfo) {
                    break;
                }
                PrintDeviceInfo(pDeviceInfo);
            }
        } else {
            printf("Find No Devices!\n");
            break;
        }
    }while(false);
}



void EDGE_CAMERA::connectCameras(){
    for(int device = 0; device < _stDeviceList.nDeviceNum; device++){
        if (!MV_CC_IsDeviceAccessible(_stDeviceList.pDeviceInfo[device], MV_ACCESS_Exclusive))
        {
            PrintDeviceInfo(_stDeviceList.pDeviceInfo[device]);
            printf("Can't connect %u! ", _stDeviceList.pDeviceInfo[device]->nMacAddrLow);
            continue;
        }else{
            void *handle;
            PrintDeviceInfo(_stDeviceList.pDeviceInfo[device]);
            printf("connect %10u!\n", _stDeviceList.pDeviceInfo[device]->nMacAddrLow);
            int nRet = MV_CC_CreateHandle(&handle, _stDeviceList.pDeviceInfo[device]);
            _handlesCameraInfos.push_back({handle,nRet}); //save the handle to handlesCameraInfos
            if (MV_OK != nRet)
            {
                printf("Create Handle fail! nRet [0x%x]\n", nRet);
            }
        }
    }
}




void EDGE_CAMERA::initCamera(void *handle, int createRetStatus, unsigned int cameraIndex) {
    int nRet;
    unsigned char * pData = nullptr;
  do{
      if (createRetStatus != MV_OK)
          break;
      handle = handle;
      // en:Open device
      nRet = MV_CC_OpenDevice(handle);
      if (MV_OK != nRet) {
          printf("Open Device fail! nRet [0x%x]\n", nRet);
          break;
      }

      // en:Detection network optimal package size(It only works for the GigE camera)
      if (MV_GIGE_DEVICE == _stDeviceList.pDeviceInfo[cameraIndex]->nTLayerType) {
          int nPacketSize = MV_CC_GetOptimalPacketSize(handle);
          if (nPacketSize > 0) {
              nRet = MV_CC_SetIntValue(handle, "GevSCPSPacketSize", nPacketSize);
              if (MV_OK != nRet) {
                  printf("Warning: Set Packet Size fail! nRet [0x%x]!", nRet);
              }
          } else {
              printf("Warning: Get Packet Size fail! nRet [0x%x]!", nPacketSize);
          }
      }

      //en:Set trigger mode as off
      nRet = MV_CC_SetEnumValue(handle, "TriggerMode", 0);
      if (MV_OK != nRet) {
          printf("Set Trigger Mode fail! nRet [0x%x]\n", nRet);
          break;
      }

      // en:Get payload size
      MVCC_INTVALUE stParam;
      memset(&stParam, 0, sizeof(MVCC_INTVALUE));
      nRet = MV_CC_GetIntValue(handle, "PayloadSize", &stParam);
      if (MV_OK != nRet) {
          printf("Get PayloadSize fail! nRet [0x%x]\n", nRet);
          break;
      }
      unsigned int nPayloadSize = stParam.nCurValue;

      // en:Init image info
      MV_FRAME_OUT_INFO_EX stImageInfo = {0};
      memset(&stImageInfo, 0, sizeof(MV_FRAME_OUT_INFO_EX));
      pData = (unsigned char *) malloc(sizeof(unsigned char) * (nPayloadSize));
      if (nullptr == pData) {
          printf("Allocate memory failed.\n");
          break;
      }
      memset(pData, 0, sizeof(pData));

      //  en:Start grab image
      nRet = MV_CC_StartGrabbing(handle);
      if (MV_OK != nRet) {
          printf("Start Grabbing fail! nRet [0x%x]\n", nRet);
          break;
      }

      _camerasDatas.push_back({handle,pData,nPayloadSize,stImageInfo});

      // en:Get one frame from camera with timeout=1000ms
  /*    while (true) {
          nRet = MV_CC_GetOneFrameTimeout(handle, pData, nPayloadSize, &stImageInfo, 1000);
          if (MV_OK == nRet) {
              printf("Get One Frame: Width[%d], Height[%d], FrameNum[%d]\n",
                     stImageInfo.nWidth, stImageInfo.nHeight, stImageInfo.nFrameNum);
          } else {
              printf("Get Frame fail! nRet [0x%x]\n", nRet);
              break;
          }

          //  en:Convert image data
          bool bConvertRet = false;
          cv::Mat img;
          bConvertRet = Convert2Mat(&stImageInfo, pData, img);
          cv::namedWindow("img", cv::WINDOW_NORMAL);
          cv::resizeWindow("img", cv::Size(900, 600));
          imshow("img", img);
          cv::waitKey(20);

      }*/
  }while(false);



      /* // en:Stop grab image
       nRet = MV_CC_StopGrabbing(handle);
       if (MV_OK != nRet)
       {
           printf("Stop Grabbing fail! nRet [0x%x]\n", nRet);
           break;
       }

       // en:Close device
       nRet = MV_CC_CloseDevice(handle);
       if (MV_OK != nRet)
       {
           printf("ClosDevice fail! nRet [0x%x]\n", nRet);
           break;
       }

       //  en:Input the format to convert
       printf("\n[0] OpenCV_Mat\n");
       printf("[1] OpenCV_IplImage\n");
       int nFormat = 0;*/


}

void EDGE_CAMERA::initAllCameras(){
    unsigned int nCameraIndex = _handlesCameraInfos.size();
    unsigned int cameraIndex = 0;
    for(auto handlesCameraInfo:_handlesCameraInfos){
        initCamera(handlesCameraInfo.handle, handlesCameraInfo.createRetStatus, cameraIndex);
        cameraIndex++;
    }
}

void EDGE_CAMERA::disPlay() {

    //initCamera(_handlesCameraInfos[0].handle, _handlesCameraInfos[0].createRetStatus, 0);
    std::string winName = "img";
    cv::namedWindow(winName, cv::WINDOW_NORMAL);
    cv::resizeWindow(winName, cv::Size(900, 600));

    while (cv::waitKey(50) != 'q') {
        unsigned int cameraIndex = 0;
        int nRet = MV_CC_GetOneFrameTimeout(_camerasDatas[0].handle, _camerasDatas[0].pData, _camerasDatas[0].nPayloadSize, &_camerasDatas[0].stImageInfo, 1000);
        if (MV_OK == nRet) {
            printf("Get One Frame: Width[%d], Height[%d], FrameNum[%d]\n",
                   _camerasDatas[0].stImageInfo.nWidth, _camerasDatas[0].stImageInfo.nHeight, _camerasDatas[0].stImageInfo.nFrameNum);
        } else {
            printf("Get Frame fail! nRet [0x%x]\n", nRet);
            break;
        }

        //  en:Convert image data
        bool bConvertRet = false;
        cv::Mat img;
        bConvertRet = Convert2Mat(&_camerasDatas[0].stImageInfo, _camerasDatas[0].pData, img);
        imshow(winName, img);
        cv::waitKey(20);
    }



}


bool EDGE_CAMERA::getAndProcessImg() {
    int nRet = MV_OK;
    void* handle = nullptr;
    unsigned char * pData = nullptr;

    do

    {
        MV_CC_DEVICE_INFO_LIST stDeviceList;
        memset(&stDeviceList, 0, sizeof(MV_CC_DEVICE_INFO_LIST));

        // en:Enum device
        nRet = MV_CC_EnumDevices(MV_GIGE_DEVICE | MV_USB_DEVICE, &stDeviceList);
        if (MV_OK != nRet)
        {
            printf("Enum Devices fail! nRet [0x%x]\n", nRet);
            break;
        }

        // en:Show devices
        if (stDeviceList.nDeviceNum > 0)
        {
            for (unsigned int i = 0; i < stDeviceList.nDeviceNum; i++)
            {
                printf("[device %d]:\n", i);
                MV_CC_DEVICE_INFO* pDeviceInfo = stDeviceList.pDeviceInfo[i];
                if (nullptr == pDeviceInfo)
                {
                    break;
                }
                PrintDeviceInfo(pDeviceInfo);
            }
        }
        else
        {
            printf("Find No Devices!\n");
            break;
        }

        // en:Select device
        unsigned int nIndex = 0;
        while (true)
        {
            printf("Please Input camera index(0-%d): ", stDeviceList.nDeviceNum - 1);

            if (1 == scanf("%d", &nIndex))
            {
                while (getchar() != '\n')
                {
                    ;
                }


                if (nIndex >= 0 && nIndex < stDeviceList.nDeviceNum)
                {
                    if (!MV_CC_IsDeviceAccessible(stDeviceList.pDeviceInfo[nIndex], MV_ACCESS_Exclusive))
                    {
                        printf("Can't connect! ");
                        continue;
                    }

                    break;
                }
            }
            else
            {
                while (getchar() != '\n')
                {
                    ;
                }
            }
        }

        // en:Create handle
        nRet = MV_CC_CreateHandle(&handle, stDeviceList.pDeviceInfo[nIndex]);

        if (MV_OK != nRet)
        {
            printf("Create Handle fail! nRet [0x%x]\n", nRet);
            break;
        }

        // en:Open device
        nRet = MV_CC_OpenDevice(handle);
        if (MV_OK != nRet)
        {
            printf("Open Device fail! nRet [0x%x]\n", nRet);
            break;
        }

        // en:Detection network optimal package size(It only works for the GigE camera)
        if (MV_GIGE_DEVICE == stDeviceList.pDeviceInfo[nIndex]->nTLayerType)
        {
            int nPacketSize = MV_CC_GetOptimalPacketSize(handle);
            if (nPacketSize > 0)
            {
                nRet = MV_CC_SetIntValue(handle, "GevSCPSPacketSize", nPacketSize);
                if (MV_OK != nRet)
                {
                    printf("Warning: Set Packet Size fail! nRet [0x%x]!", nRet);
                }
            }
            else
            {
                printf("Warning: Get Packet Size fail! nRet [0x%x]!", nPacketSize);
            }
        }

        //en:Set trigger mode as off
        nRet = MV_CC_SetEnumValue(handle, "TriggerMode", 0);
        if (MV_OK != nRet)
        {
            printf("Set Trigger Mode fail! nRet [0x%x]\n", nRet);
            break;
        }

        // en:Get payload size
        MVCC_INTVALUE stParam;
        memset(&stParam, 0, sizeof(MVCC_INTVALUE));
        nRet = MV_CC_GetIntValue(handle, "PayloadSize", &stParam);
        if (MV_OK != nRet)
        {
            printf("Get PayloadSize fail! nRet [0x%x]\n", nRet);
            break;
        }
        unsigned int nPayloadSize = stParam.nCurValue;

        // en:Init image info
        MV_FRAME_OUT_INFO_EX stImageInfo = { 0 };
        memset(&stImageInfo, 0, sizeof(MV_FRAME_OUT_INFO_EX));
        pData = (unsigned char *)malloc(sizeof(unsigned char)* (nPayloadSize));
        if (nullptr == pData)
        {
            printf("Allocate memory failed.\n");
            break;
        }
        memset(pData, 0, sizeof(pData));

        //  en:Start grab image
        nRet = MV_CC_StartGrabbing(handle);
        if (MV_OK != nRet)
        {
            printf("Start Grabbing fail! nRet [0x%x]\n", nRet);
            break;
        }

        // en:Get one frame from camera with timeout=1000ms
        nRet = MV_CC_GetOneFrameTimeout(handle, pData, nPayloadSize, &stImageInfo, 1000);
        if (MV_OK == nRet)
        {
            printf("Get One Frame: Width[%d], Height[%d], FrameNum[%d]\n",
                   stImageInfo.nWidth, stImageInfo.nHeight, stImageInfo.nFrameNum);
        }
        else
        {
            printf("Get Frame fail! nRet [0x%x]\n", nRet);
            break;
        }

        // en:Stop grab image
        nRet = MV_CC_StopGrabbing(handle);
        if (MV_OK != nRet)
        {
            printf("Stop Grabbing fail! nRet [0x%x]\n", nRet);
            break;
        }

        // en:Close device
        nRet = MV_CC_CloseDevice(handle);
        if (MV_OK != nRet)
        {
            printf("ClosDevice fail! nRet [0x%x]\n", nRet);
            break;
        }

        //  en:Input the format to convert
        printf("\n[0] OpenCV_Mat\n");
        printf("[1] OpenCV_IplImage\n");
        int nFormat = 0;
        while (1)
        {
            printf("Please Input Format to convert: ");

            if (1 == scanf("%d", &nFormat))
            {

                if (0 == nFormat || 1 == nFormat)
                {
                    break;
                }
            }
            while (getchar() != '\n')
            {
                ;
            }
        }

        //  en:Convert image data
        bool bConvertRet = false;
        cv::Mat img;
        if (OpenCV_Mat == nFormat)
        {
            bConvertRet = Convert2Mat(&stImageInfo, pData, img);
        }
        else if (OpenCV_IplImage == nFormat)
        {
            bConvertRet = Convert2Ipl(&stImageInfo, pData);
        }

        //  en:Print result
        if (bConvertRet)
        {
            printf("OpenCV format convert finished.\n");
        }
        else
        {
            printf("OpenCV format convert failed.\n");
        }

    } while (0);

    // en:Destroy handle
    if (handle)
    {
        MV_CC_DestroyHandle(handle);
        handle = nullptr;
    }

    // en:Free memery
    if (pData)
    {
        free(pData);
        pData = nullptr;
    }
    return true;
}


void EDGE_CAMERA::saveImg(std::string path,unsigned int cameraIndex){

}

Main函数

int main(int argc, char **argv){
  EDGE_CAMERA camera;
   camera.findCameras();
   camera.connectCameras();
   camera.initAllCameras();
   camera.disPlay();
   }

执行效果

在这里插入图片描述

注意

我是编译了一个动态库cameraAPI，main函数是链接的camkeraAPI。上面是把最重要的代码给贴出来了。不是完整的工程哈。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/940435.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

3d Max因卡顿未保存？有什么保护文件和恢复操作呢？

3d Max因卡顿未保存？有什么保护文件和恢复操作呢？

大家在使用3d Max进行建模、渲染和动画制作的过程中&#xff0c;由于各种原因导致软件卡顿或崩溃是很常见的情况。 当卡顿发生时&#xff0c;如果之前的工作没有及时保存&#xff0c;可能会导致数据的丢失和时间的浪费。 一、先来看看保护文件 1、自动保存设置 3d Max提供了自…
阅读更多...
一文快速读懂数据安全平台的优势与价值，让数据安全化繁为简

一文快速读懂数据安全平台的优势与价值，让数据安全化繁为简

在大数据时代&#xff0c;数据已经成为公司的核心竞争力。《数字中国建设整体布局规划》为数字中国建设提出了“2522”整体框架布局&#xff0c;其中明确将“数字安全屏障”作为战略实施的两大关键能力之一&#xff0c;表明了数据安全是数字经济背后的重要工作。 广泛的数字化转…
阅读更多...
python数组基本使用

python数组基本使用

使用Numpy进行数组运算 相比 List&#xff0c;NumPy 数组的优势 NumPy 全称为 Numerical Python&#xff0c;是 Python 的一个以矩阵为主的用于科学计算的基础软件包。NumPy 和 Pandas、Matpotlib 经常结合一起使用&#xff0c;所以被人们合称为数据分析三剑客。Numpy 中有功能…
阅读更多...
网卡挂载与连接wifi

网卡挂载与连接wifi

Viobot设备本身不具备无线功能&#xff0c;我们其实更推荐使用有线连接的方式使用&#xff0c;这样会更稳定&#xff0c;但如果确实想要使用无线测试的话&#xff0c;我们提供了无线网卡的驱动和安装方式。 无线网卡驱动属于外接的驱动&#xff0c;需要编译系统对应的驱动文件…
阅读更多...
win10电脑记事本在哪里？电脑记事本如何查看字数？

win10电脑记事本在哪里？电脑记事本如何查看字数？

在日常工作中&#xff0c;我们会遇到许多需要记录的信息和事项&#xff0c;而使用电脑记事本工具可以帮助我们方便地保存、管理这些内容。无论是记录工作会议的要点、制定工作计划&#xff0c;还是记录灵感和创意&#xff0c;电脑记事本都是非常实用的工具。 那么win10电脑记事…
阅读更多...
nacos服务器启动报错集合

nacos服务器启动报错集合

报错1 Error creating bean with name ‘user‘: Unsatisfied dependency expressed through field ‘jwtTokenManage 开启鉴权之后&#xff0c;你可以自定义用于生成JWT令牌的密钥&#xff0c;application.properties中的配置信息为&#xff1a; ### Since 1.4.1, worked when…
阅读更多...
银联iso8583协议报文解析

银联iso8583协议报文解析

最近在研究银联的ISO8583协议&#xff0c;涉及到报文这方面的东西&#xff0c;感觉挺多的&#xff0c;分享一下&#xff0c;或许对你有帮助。 ISO8583协议解决的核心问题&#xff1a; 明确了报文每个字段的数据类型&#xff0c;是数字还是字符&#xff0c;都能定义清楚 支持64…
阅读更多...
ARMS 助力极氪提效服务应急响应，为安全出行保驾护航

ARMS 助力极氪提效服务应急响应，为安全出行保驾护航

作者&#xff1a;比扬 01 客户介绍与项目背景 浙江极氪智能科技有限公司于 2021 年 3 月成立&#xff0c;2021 年 4 月发布极氪品牌及旗下首款产品——极氪 001。极氪是一家以智能化、数字化、数据驱动的智能出行科技公司&#xff0c;秉承用户型企业理念&#xff0c;聚焦智能…
阅读更多...
DNS指向别名还是IP

DNS指向别名还是IP

现在有一台服务器dbprod126&#xff0c;ip是172.22.100.4 现在有一个需求&#xff0c;需要在dns中对dbprod126建一个别名wondadb3r的记录&#xff0c;也就是ping wondadb3r的时候显示的是dbprod126的ip&#xff0c;目前有两​种方法&#xff0c;主要使用方法1指向别名&#xf…
阅读更多...
matplotlib基础--2

matplotlib基础--2

5 图例 matplotlib中的图例是帮助观察者理解图像数据的重要工具。图列通常包含在图像中&#xff0c;用于解释不同的颜色、形状、标签和其它元素。 1&#xff09;主要参数 当不设置图例的参数时&#xff0c;默认的图例是这样的。 x np.linspace(0,1,50) y1 np.sin(x*2*np.p…
阅读更多...
【unity插件】使用BehaviorDesigner插件制作BOSS的AI行为树

【unity插件】使用BehaviorDesigner插件制作BOSS的AI行为树

文章目录 前言素材插件一、基础使用二、敌人物理攻击三、敌人面向玩家四、敌人法术攻击五、随机进行攻击六、敌人不同的阶段推荐学习视频源码完结 前言 Behavior Designer是一个行为树插件&#xff0c;是一款为了让策划&#xff0c;程序员&#xff0c;美术人员方便使用的可视化…
阅读更多...
基于SSM技客户管理系统源码和论文

基于SSM技客户管理系统源码和论文

基于SSM技客户管理系统源码和论文079 开发工具&#xff1a;idea 数据库mysql5.7 数据库链接工具&#xff1a;navcat,小海豚等 技术&#xff1a;ssm 一、课题的背景和意义 1、课题目的 客户管理是每个企业中最重要的模块&#xff0c;对客户的分类管理有利于更有效地了解从…
阅读更多...
RHCE——九、SELinux

RHCE——九、SELinux

SELinux 一、概念1、作用2、SELinux与传统的权限区别 二、SELinux工作原理1、名词解释主体&#xff08;Subject&#xff09;目标&#xff08;Object&#xff09;策略&#xff08;Policy&#xff09;安全上下文&#xff08;Security Context&#xff09; 2、文件安全上下文查看1…
阅读更多...
java入门第三节

java入门第三节

java入门第三节 一.什么是oop 1.pop与oop (1).面向过程编程&#xff1a;&#xff08;POP&#xff1a;Procedure Oriented Programming&#xff09; 1.步骤清晰简单&#xff0c;第一步做什么&#xff0c;第二步做什么&#xff0c;按照顺序&#xff1b; 2.代码线性&#xff0…
阅读更多...
什么是 TEE

什么是 TEE

参考文献&#xff1a; Sabt M, Achemlal M, Bouabdallah A. Trusted execution environment: what it is, and what it is not[C]//2015 IEEE Trustcom/BigDataSE/Ispa. IEEE, 2015, 1: 57-64. “U.S. government protection profifile for separation kernels in environment…
阅读更多...
svn软连接和文件忽略

svn软连接和文件忽略

软连接 1)TortoiseSVN->Properties->New->Externals->New 2)填入软连接信息 Local path: 写下软连接后的文件夹的名字 URL: 想要软连接的牡蛎->TortoiseSVN->Repo-browser 复制下填入 文件忽略 以空格隔开就行
阅读更多...
CentOS 7 Nacos 设置开机自动重启

CentOS 7 Nacos 设置开机自动重启

一、说明 Nacos如果是手动启动的话&#xff0c;在服务器宕机或者重启后&#xff0c;没有自动运行&#xff0c;影响很多业务系统&#xff0c;需要每次手动执行命令 startup.sh -m standalone&#xff0c;才能启动 Nacos 服务&#xff0c;不能像docker服务一样&#xff0c;使用 …
阅读更多...
「Vue｜网页开发｜前端开发」01 快速入门：快速写一个Vue的HelloWorld项目

「Vue｜网页开发｜前端开发」01 快速入门：快速写一个Vue的HelloWorld项目

本文主要介绍如何用vue开发的标准化工具vue-cli快速搭建一个符合实际业务项目结构的hello world网页项目并理解vue的代码文件结构以及页面渲染流程。 文章目录 一、准备工作&#xff1a;安装node.js二、项目搭建创建项目目录全局安装vue-cli使用Webpack初始化项目启动项目学会…
阅读更多...
Prometheus关于微服务的监控

Prometheus关于微服务的监控

在微服务架构下随着服务越来越多，定位问题也变得越来越复杂，因此监控服务的运行状态以及针对异常状态及时的发出告警也成为微服务治理不可或缺的一环。服务的监控主要有日志监控、调用链路监控、指标监控等几种类型方式，其中指标监控在整个微服务监控中比重最高，也是实际生…
阅读更多...
支持库和应用条

支持库和应用条

每个Android新版本都会引入一些新特性&#xff0c;不过并不是每个人都能做到Android一推出新版本就升级到那个最新版本&#xff0c;实际上&#xff0c;大多数人都至少落后一个版本。而支持库允许在老版本的Android上使用新特性。 Andriod支持库提供了对Android老版本的向后兼容…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023