1. Toy模板网首页
  2. > Toy博客

海康威视相机-LINUX SDK 开发

9月前 作者：rosLAB 分类：Toy博客 阅读(43) 违法举报

这篇具有很好参考价值的文章主要介绍了海康威视相机-LINUX SDK 开发。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

硬件与环境

海康威视相机-LINUX SDK 开发,计算机视觉

相机： MV-CS020-10GC
系统：UBUNTU 22.04
语言：C++
工具：cmake
海康官网下载SDK
海康威视相机-LINUX SDK 开发,计算机视觉

海康威视相机-LINUX SDK 开发,计算机视觉
运行下面的命令进行安装

sudo dpkg -i  MVSXXX.deb

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

make

海康威视相机-LINUX SDK 开发,计算机视觉
这里是我运行了/opt/MVS/Samples/64/Display下的例子。

海康威视相机-LINUX SDK 开发,计算机视觉

开发

实际上我们开发的时候只需要目录/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();
   }

执行效果

海康威视相机-LINUX SDK 开发,计算机视觉

注意

我是编译了一个动态库cameraAPI，main函数是链接的camkeraAPI。上面是把最重要的代码给贴出来了。不是完整的工程哈。文章来源地址https://www.toymoban.com/news/detail-681218.html

到了这里，关于海康威视相机-LINUX SDK 开发的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 基于海康威视的SDK实现二次开发

    基于海康威视的SDK实现二次开发

    因为网上关于海康威视SDK这块的开发资源比较少，自己也是一步一步摸索过来，知道那种痛苦， 所以把自己的一些过来人的经验写出来供大家学习参考 进入海康威视官网 下载你所需要的SDK开发包（这里我就用windows来作为案列） 下载完SDK解压 里面有开发文档和SDK的动态库文

    2024年04月10日
    浏览(45)
  • 【Python】基于Python和Qt的海康威视相机开发

    【Python】基于Python和Qt的海康威视相机开发

    【项目实践】海康威视工业相机SDK开发小白版入门教程（VS2015+OpenCV4.5.1）   此前写了一篇基于C++开发海康威视相机的博客，貌似看的人还挺多，收藏量比较高，但其实当时就知道其实海康威视相机还可以使用python开发，但当时python水平不高，也没有深入了解，趁此机会，好

    2024年02月16日
    浏览(50)

  • 海康相机开发：SDK安装和ARM开发

    在海康相机开发过程中，首先需要进行SDK的安装和ARM平台的开发。本文将详细介绍如何安装海康相机SDK并进行ARM开发，包括安装步骤和相关源代码。 一、SDK安装步骤： 下载SDK：访问海康官方网站，找到相机SDK的下载页面，根据所需的平台选择合适的SDK版本进行下载。 安装

    2024年02月03日
    浏览(83)
  • C# 上位机之海康相机开发(SDK)

    C# 上位机之海康相机开发(SDK)

    发现工作中好多计算机视觉上位机项目都用海康相机，为了能够更好的学习和工作，我自己依据同事的源码和网上的一些总结编写本博客。通过本次学习，让我明白一点，无论学习什么技术都要学会自己看技术文档，而不是第一时间上网找源码。以工业相机SDK使用说明.chm为例

    2024年02月03日
    浏览(53)
  • 【HIKROBOT】海康机器人：工业相机SDK二次开发

    【HIKROBOT】海康机器人：工业相机SDK二次开发

    海康机器人官网链接：https://www.hikrobotics.com/cn 根据购买设备的型号下载用户说明书 笔者实验室购买了两款，一款GigE网口接口的，一款USB接口 GigE网口接口 USB接口：MV-CA050-20UC 服务支持”“下载中心”“机器视觉”中下载MVS客户端安装包及SDK开发包。 1.1.1 Ubuntu18.04系统安装 下

    2024年02月05日
    浏览(62)

  • 【记录】海康相机（SDK）二次开发时的错误码

    在进行海康sdk二次开发的时候，经常碰到各种错误，遂结合官方文档和广大网友的一些经验，把这些错误码记录一下，方便查找。笔者使用的SDK版本是HCNetSDKV6.1.9.4。 错误类型 错误码 错误信息 NET_DVR_NOERROR 0 没有错误。 NET_DVR_PASSWORD_ERROR 1 用户名密码错误。注册时输入的用户名

    2024年04月08日
    浏览(83)
  • （一）Qt+OpenCV调用海康工业相机SDK示例开发

    （一）Qt+OpenCV调用海康工业相机SDK示例开发

    提示：这里是该系列文章的所有文章的目录 第一章： （一）Qt+OpenCV调用海康工业相机SDK示例开发 第二章： （二）Qt多线程实现海康工业相机图像实时采集 近期在Qt环境下进行海康工业相机的使用开发，发现海康提供的示例没有Qt的demo，而其中有基于MFC框架的示例，所以在这

    2024年02月03日
    浏览(99)
  • 基于海康SDK实现Python调用海康威视网络摄像头

    基于海康SDK实现Python调用海康威视网络摄像头

    本文参考博客，写得很好： Python调用海康威视网络相机之——python调用海康威视C++的SDK Python调用海康威视网络相机C++的SDK 写本文的目的，也是快速复盘，所以没有很详细 保存视频流到本地可参考下一篇：基于海康SDK实现Python保存海康威视网络摄像头拍摄的视频 Windows11 Vis

    2024年02月02日
    浏览(67)
  • 海康威视SDK视频录制及强制I帧操作

    海康威视SDK视频录制及强制I帧操作

    使用下面方法可以实现视频录像功能。 该方法有个问题，视频可以录制，但是不能被前端页面直接加载播放，因为视频编码格式问题，虽然可以用FFMPEG工具进行格式转化，但是引入第三方的库，无疑会使代码的维护性降低。 FFMPEG工具 地址 提取码 zc14 使用FFmpeg进行转换的方法

    2023年04月24日
    浏览(80)

  • Python海康威视SDK实现实时预览：快速构建高效视频监控系统

    Python海康威视SDK实现实时预览：快速构建高效视频监控系统 在当今社会，安全问题越来越受到人们的关注，越来越多的企业和机构开始建设视频监控系统。而Python作为一种高效、易用的编程语言，已经成为了许多开发人员的首选。本文将介绍如何使用Python海康威视SDK来实现实

    2024年02月14日
    浏览(57)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包