精华内容
下载资源
问答
  • 工业相机

    2020-04-03 18:28:25
    工业相机是机器视觉系统的重要组成部分,其功能是通过CCD或CMOS成像传感器将镜头接收到的光学信号转换为对应的模拟信号或数字信号,并将这些信息由相机与计算机的接口传送到计算机主机。 典型结构 2、工业相机分类...

    本文总结自大恒图像培训课程
    1、概述

    • 工业相机
      工业相机是机器视觉系统的重要组成部分,其功能是通过CCD或CMOS成像传感器将镜头接收到的光学信号转换为对应的模拟信号或数字信号,并将这些信息由相机与计算机的接口传送到计算机主机。
    • 典型结构
      在这里插入图片描述

    2、工业相机分类

    • 模拟相机和数字相机
      工业相机按输出图像信号格式划分为模拟相机与数字相机,目前工业上多采用数字相机。
    • 面阵相机和线阵相机
      按传感器像素排列方式划分
      • 面阵相机
        • 阵列排列:阵列中的每一个感光单元对应一个像素,拍摄目标的一个面被成像,目标与相机之间是静止的,也可以在一定条件下相对运动的。
        • 可以短时间内曝光、一次性获取完整的目标图像常应用于测量目标物体的形状、尺寸与温度等信息。
      • 线阵相机
        • 感光单元排列是一维的,每次曝光仅是目标上的一条线被成像,形成一行图像,随着目标物体与相机之间的相对运动,相机连续曝光,最后形成一幅二维图像。
        • 幅面宽,图像纵向方式尺寸较灵活,采集频率高,常应用于一维动态目标的测量,如需要极大的视野或极高的精度或被测视野为细长的带状,也多用于曲面检测的问题。

    3、传感器芯片类型
    传感器是相机的核心部件,目前相机常用的感光芯片有CCD和CMOS两类。

    • CCD:所有的电荷全部经过一个“放大器”进行电压转变,形成电子信号。
    • CMOS:每一个像素点都有一个单独的放大器转换输出,能够在短时间内处理大量数据。

    4、常见术语与参数

    • 扫描方式
      是指CCD或CMOS中像素的输出方式
      • 隔离扫描
        将一幅图像分为两场,奇数行为一场,偶数行为一场,两场按规定先后顺序输出。
      • 逐行扫描
        将一幅图像的所有行,从第一行到最后一行按顺序逐行输出,机器视觉中使用的相机多采用逐行扫描。
    • 曝光方式
      • 帧曝光
        • 传感器阵列中所有像素同时曝光,曝光周期由预先设定的快门时间确定。
        • 拍摄运动物体,图像不会偏移,不会失真。
      • 行曝光
        • 同一行的像素同时曝光,不同行的曝光起始时间不同,每行的曝光时间是相同的,行间延迟不变。
        • 适用于拍摄静止的物体,拍摄运动物体,图像会偏移。
    • 传感器尺寸
      传感器尺寸通常以有效面积(宽*高)或对角线尺寸(英寸)表示
      在这里插入图片描述
    • 分辨率
      分辨率通常以水平方向和垂直方向的像素数或套用计算机显示使用的方法表示
    • 像元尺寸
      • 像元尺寸就是每个像素的面积
      • 单个像素面积小,单位面积内的像素数就越多,相机的分辨率增加,利于细小缺陷的检测和增大检测视场
      • 随着随着像素面积的缩小,满陷能力(每个像素能够存储的电荷数量)也随之减少,造成相机动态范围的降低。
    • 其它常见参数

    在这里插入图片描述

    5、数据输出方式

    • 接口与协议

    在这里插入图片描述

    展开全文
  • 普通相机VS工业相机

    2021-01-20 02:18:59
    普通相机与工业相机的几点区别:  1、工业相机的快门时间非常短,可以抓拍快速运动的物体。  举个例子,把一张名片贴在电风扇扇叶上,以速度旋转,用工业相机抓拍一张图像,能清晰的辨别名片上的字体。然而用...
  • 工业相机选型

    2019-01-16 17:26:23
    1.工业相机镜头的参数与选型 2.工业相机如何选型工业相机选型技巧 3.那么为何在镜头的选用中考虑CCD靶面的尺寸呢
  • 普通相机与工业相机的几点区别:  1、工业相机的快门时间非常短,可以抓拍快速运动的物体。  举个例子,把一张名片贴在电风扇扇叶上,以最大速度旋转,用工业相机抓拍一张图像,能清晰的辨别名片上的字体。然而...
  • Qt(C++)调用工业相机Basler的SDK使用示例

    万次阅读 多人点赞 2017-12-19 16:56:24
    简介 由于公司采购的AVT相机不足,需要用Basler相机来弥补,所以我也了解了一下Basler这款相机的SDK。...如果不是,那么我们最好选用黑白工业相机,因为在同样分辨率下的工业相机,黑白工业教学精度比彩色工...

    简介

    由于公司采购的AVT相机不足,需要用Basler相机来弥补,所以我也了解了一下Basler这款相机的SDK。由于Basler这边的相机提供的没有提供Qt的示例,所以我做一个分享出来。

    本篇的Demo采用的是工业黑白相机。工业应用中,如果我们要处理的是与图像颜色有关,那么我们最好采用彩色工业相机;如果不是,那么我们最好选用黑白工业相机,因为在同样分辨率下的工业相机,黑白工业教学精度比彩色工业相机高,尤其是在看图像边缘的时候,黑白工业相机的效果更好。

    开发环境

    Qt:  5.6.2vc2013版 

    Basler:  5.0.11版

    效果图

     

    上图只是做了SDK部分接口的获取和设置。相机的触发方式、曝光时间、增益、频率,以及图片的尺寸、灯的触发信号等。

    Basler相机SDK接口调用控制类

    #ifndef SBASLERCAMERACONTROL_H
    #define SBASLERCAMERACONTROL_H
    
    #include <QObject>
    #include <pylon/PylonIncludes.h>
    #include <QImage>
    #include <QTimer>
    
    #define DOUBLE_MAX 100000
    #define DOUBLE_MIN 0
    
    using namespace std;
    using namespace Pylon;
    using namespace GenApi;
    class SBaslerCameraControl : public QObject
    {
        Q_OBJECT
    public:
        explicit SBaslerCameraControl(QObject *parent = 0);
        ~SBaslerCameraControl();
    
        enum SBaslerCameraControl_Type{
            Type_Basler_Freerun, //设置相机的内触发
            Type_Basler_Line1, //设置相机的外触发
            Type_Basler_ExposureTimeAbs, //设置相机的曝光时间
            Type_Basler_GainRaw, //设置相机的增益
            Type_Basler_AcquisitionFrameRateAbs, //设置相机的频率
            Type_Basler_Width, //图片的宽度
            Type_Basler_Height, //图片的高度
            Type_Basler_LineSource, //灯的触发信号
        };
        void initSome();
        void deleteAll();
        QStringList cameras();
        int OpenCamera(QString cameraSN);
        int CloseCamera();
    
        void setExposureTime(double time); // 设置曝光时间
        int getExposureTime(); // 获取曝光时间
        int getExposureTimeMin(); // 最小曝光时间
        int getExposureTimeMax(); // 最大曝光时间
    
        void setFeatureTriggerSourceType(QString type); // 设置种类
        QString getFeatureTriggerSourceType(); // 获取种类:软触发、外触发等等
    
        void setFeatureTriggerModeType(bool on); // 设置模式触发
        bool getFeatureTriggerModeType(); // 获取模式触发
        void SetCamera(SBaslerCameraControl::SBaslerCameraControl_Type index, double tmpValue = 0.0); // 设置各种参数
        double GetCamera(SBaslerCameraControl::SBaslerCameraControl_Type index); // 获取各种参数
    
        long GrabImage(QImage& image,int timeout = 2000);
        long StartAcquire(); // 开始采集
        long StopAcquire(); // 结束采集
    signals:
        void sigCameraUpdate(QStringList list);
        void sigSizeChange(QSize size);
        void sigCameraCount(int count);
        void sigCurrentImage(QImage img);
    private:
        void UpdateCameraList();
        void CopyToImage(CGrabResultPtr pInBuffer, QImage &OutImage);
    private slots:
        void onTimerGrabImage();
    private:
        CInstantCamera m_basler;
        QStringList m_cameralist;
        QString m_currentMode;
        bool m_isOpenAcquire = false; // 是否开始采集
        bool m_isOpen = false; // 是否打开摄像头
        QSize m_size;
    };
    
    #endif // SBASLERCAMERACONTROL_H
    

    源文件:

    #include "sbaslercameracontrol.h"
    #include <QDateTime>
    #include <QDebug>
    
    SBaslerCameraControl::SBaslerCameraControl(QObject *parent) : QObject(parent)
    {
    }
    
    SBaslerCameraControl::~SBaslerCameraControl()
    {
    }
    
    void SBaslerCameraControl::initSome()
    {
        qDebug() << "SBaslerCameraControl: PylonInitialize initSome" ;
        PylonInitialize();
        CTlFactory &TlFactory = CTlFactory::GetInstance();
        TlInfoList_t lstInfo;
        int n = TlFactory.EnumerateTls(lstInfo);
    
        TlInfoList_t::const_iterator it;
        for ( it = lstInfo.begin(); it != lstInfo.end(); ++it ) {
            qDebug() << "FriendlyName: " << it->GetFriendlyName() << "FullName: " << it->GetFullName();
            qDebug() << "VendorName: " << it->GetVendorName() << "DeviceClass: " << it->GetDeviceClass() ;
        }
        UpdateCameraList();
        emit sigCameraCount(n);
        qDebug() << "SBasler Camera Count: " << n;
    }
    
    void SBaslerCameraControl::deleteAll()
    {
        //停止采集
        if(m_isOpenAcquire) {
            StopAcquire();
        }
        //关闭摄像头
        CloseCamera();
        //关闭库
        qDebug() << "SBaslerCameraControl deleteAll: PylonTerminate" ;
        PylonTerminate();
        qDebug() << "SBaslerCameraControl deleteAll: Close" ;
    }
    
    QStringList SBaslerCameraControl::cameras()
    {
        return m_cameralist;
    }
    
    void SBaslerCameraControl::UpdateCameraList()
    {
        CTlFactory& TLFactory = CTlFactory::GetInstance();
        ITransportLayer * pTl = TLFactory.CreateTl("BaslerGigE");
        DeviceInfoList_t devices;
        int n = pTl->EnumerateDevices(devices);
        CInstantCameraArray cameraArray(devices.size());
        if(n == 0) {
            qDebug() << "Cannot find Any camera!";
            return;
        }
        for (int i=0 ; i<cameraArray.GetSize() ; i++) {
            cameraArray[i].Attach(TLFactory.CreateDevice(devices[i]));
            string sn = cameraArray[i].GetDeviceInfo().GetSerialNumber();
            m_cameralist << QString::fromStdString(sn);
        }
        emit sigCameraUpdate(m_cameralist);
    }
    
    void SBaslerCameraControl::CopyToImage(CGrabResultPtr pInBuffer, QImage &OutImage)
    {
        uchar* buff = (uchar*)pInBuffer->GetBuffer();
        int nHeight = pInBuffer->GetHeight();
        int nWidth = pInBuffer->GetWidth();
        if(m_size != QSize(nWidth, nHeight)) {
            m_size = QSize(nWidth, nHeight);
            emit sigSizeChange(m_size);
        }
        QImage imgBuff(buff, nWidth, nHeight, QImage::Format_Indexed8);
        OutImage = imgBuff;
        if(pInBuffer->GetPixelType() == PixelType_Mono8) {
            uchar* pCursor = OutImage.bits();
            if ( OutImage.bytesPerLine() != nWidth ) {
                for ( int y=0; y<nHeight; ++y ) {
                    pCursor = OutImage.scanLine( y );
                    for ( int x=0; x<nWidth; ++x ) {
                        *pCursor =* buff;
                        ++pCursor;
                        ++buff;
                    }
                }
            } else {
                memcpy( OutImage.bits(), buff, nWidth * nHeight );
            }
        }
    }
    
    void SBaslerCameraControl::onTimerGrabImage()
    {
        if(m_isOpenAcquire) {
            QImage image;
            GrabImage(image, 5);
            if(!image.isNull()) {
                emit sigCurrentImage(image);
            }
            QTimer::singleShot(5, this, SLOT(onTimerGrabImage()));
        }
    }
    
    int SBaslerCameraControl::OpenCamera(QString cameraSN)
    {
        try {
            CDeviceInfo cInfo;
            String_t str = String_t(cameraSN.toStdString().c_str());
            cInfo.SetSerialNumber(str);
            m_basler.Attach(CTlFactory::GetInstance().CreateDevice(cInfo));
            m_basler.Open();
            //获取触发模式
            getFeatureTriggerSourceType();
            m_isOpen = true;
        } catch (GenICam::GenericException &e) {
            OutputDebugString(L"OpenCamera Error\n");
            m_isOpen = false;
            return -2;
        }
        return 0;
    }
    
    int SBaslerCameraControl::CloseCamera()
    {
        if(!m_isOpen) {
            return -1;
        }
        try {
            if(m_basler.IsOpen()) {
                m_basler.DetachDevice();
                m_basler.Close();
            }
        } catch (GenICam::GenericException &e) {
            OutputDebugString(LPCWSTR(e.GetDescription()));
            return -2;
        }
        return 0;
    }
    
    void SBaslerCameraControl::setExposureTime(double time)
    {
        SetCamera(Type_Basler_ExposureTimeAbs, time);
    }
    
    int SBaslerCameraControl::getExposureTime()
    {
        return QString::number(GetCamera(Type_Basler_ExposureTimeAbs)).toInt();
    }
    
    int SBaslerCameraControl::getExposureTimeMin()
    {
        return DOUBLE_MIN;
    }
    
    int SBaslerCameraControl::getExposureTimeMax()
    {
        return DOUBLE_MAX;
    }
    
    void SBaslerCameraControl::setFeatureTriggerSourceType(QString type)
    {
        //停止采集
        if(m_isOpenAcquire) {
            StopAcquire();
        }
        if(type == "Freerun") {
            SetCamera(Type_Basler_Freerun);
        } else if(type == "Line1"){
            SetCamera(Type_Basler_Line1);
        }
    }
    
    QString SBaslerCameraControl::getFeatureTriggerSourceType()
    {
        INodeMap &cameraNodeMap = m_basler.GetNodeMap();
        CEnumerationPtr  ptrTriggerSel = cameraNodeMap.GetNode ("TriggerSelector");
        ptrTriggerSel->FromString("FrameStart");
        CEnumerationPtr  ptrTrigger  = cameraNodeMap.GetNode ("TriggerMode");
        ptrTrigger->SetIntValue(1);
        CEnumerationPtr  ptrTriggerSource = cameraNodeMap.GetNode ("TriggerSource");
    
        String_t str = ptrTriggerSource->ToString();
        m_currentMode = QString::fromLocal8Bit(str.c_str());
        return m_currentMode;
    }
    
    void SBaslerCameraControl::setFeatureTriggerModeType(bool on)
    {
        INodeMap &cameraNodeMap = m_basler.GetNodeMap();
        CEnumerationPtr  ptrTriggerSel = cameraNodeMap.GetNode ("TriggerSelector");
        ptrTriggerSel->FromString("FrameStart");
        CEnumerationPtr  ptrTrigger  = cameraNodeMap.GetNode ("TriggerMode");
        ptrTrigger->SetIntValue(on?1:0);
    }
    
    bool SBaslerCameraControl::getFeatureTriggerModeType()
    {
        INodeMap &cameraNodeMap = m_basler.GetNodeMap();
        CEnumerationPtr  ptrTriggerSel = cameraNodeMap.GetNode ("TriggerSelector");
        ptrTriggerSel->FromString("FrameStart");
        CEnumerationPtr  ptrTrigger  = cameraNodeMap.GetNode ("TriggerMode");
        return ptrTrigger->GetIntValue() == 1;
    }
    
    void SBaslerCameraControl::SetCamera(SBaslerCameraControl::SBaslerCameraControl_Type index, double tmpValue)
    {
        INodeMap &cameraNodeMap = m_basler.GetNodeMap();
        switch (index) {
        case Type_Basler_Freerun: {
            CEnumerationPtr  ptrTriggerSel = cameraNodeMap.GetNode ("TriggerSelector");
            ptrTriggerSel->FromString("FrameStart");
            CEnumerationPtr  ptrTrigger  = cameraNodeMap.GetNode ("TriggerMode");
    #ifdef Real_Freerun
            ptrTrigger->SetIntValue(0);
    #else //Software
            ptrTrigger->SetIntValue(1);
            CEnumerationPtr  ptrTriggerSource = cameraNodeMap.GetNode ("TriggerSource");
            ptrTriggerSource->FromString("Software");
    #endif
        } break;
        case Type_Basler_Line1: {
            CEnumerationPtr  ptrTriggerSel = cameraNodeMap.GetNode ("TriggerSelector");
            ptrTriggerSel->FromString("FrameStart");
            CEnumerationPtr  ptrTrigger  = cameraNodeMap.GetNode ("TriggerMode");
            ptrTrigger->SetIntValue(1);
            CEnumerationPtr  ptrTriggerSource = cameraNodeMap.GetNode ("TriggerSource");
            ptrTriggerSource->FromString("Line1");
        } break;
        case Type_Basler_ExposureTimeAbs: {
            const CFloatPtr exposureTime = cameraNodeMap.GetNode("ExposureTimeAbs");
            exposureTime->SetValue(tmpValue);
        } break;
        case Type_Basler_GainRaw: {
            const CIntegerPtr cameraGen = cameraNodeMap.GetNode("GainRaw");
            cameraGen->SetValue(tmpValue);
        } break;
        case Type_Basler_AcquisitionFrameRateAbs: {
            const CBooleanPtr frameRate = cameraNodeMap.GetNode("AcquisitionFrameRateEnable");
            frameRate->SetValue(TRUE);
            const CFloatPtr frameRateABS = cameraNodeMap.GetNode("AcquisitionFrameRateAbs");
            frameRateABS->SetValue(tmpValue);
        } break;
        case Type_Basler_Width: {
            const CIntegerPtr widthPic = cameraNodeMap.GetNode("Width");
            widthPic->SetValue(tmpValue);
        } break;
        case Type_Basler_Height: {
            const CIntegerPtr heightPic = cameraNodeMap.GetNode("Height");
            heightPic->SetValue(tmpValue);
        } break;
        case Type_Basler_LineSource: {
            CEnumerationPtr  ptrLineSource = cameraNodeMap.GetNode ("LineSource");
            ptrLineSource->SetIntValue(2);
        } break;
        default:
            break;
        }
    }
    
    double SBaslerCameraControl::GetCamera(SBaslerCameraControl::SBaslerCameraControl_Type index)
    {
        INodeMap &cameraNodeMap = m_basler.GetNodeMap();
        switch (index) {
        case Type_Basler_ExposureTimeAbs: {
            const CFloatPtr exposureTime = cameraNodeMap.GetNode("ExposureTimeAbs");
            return exposureTime->GetValue();
        } break;
        case Type_Basler_GainRaw: {
            const CIntegerPtr cameraGen = cameraNodeMap.GetNode("GainRaw");
            return cameraGen->GetValue();
        } break;
        case Type_Basler_AcquisitionFrameRateAbs: {
            const CBooleanPtr frameRate = cameraNodeMap.GetNode("AcquisitionFrameRateEnable");
            frameRate->SetValue(TRUE);
            const CFloatPtr frameRateABS = cameraNodeMap.GetNode("AcquisitionFrameRateAbs");
            return frameRateABS->GetValue();
        } break;
        case Type_Basler_Width: {
            const CIntegerPtr widthPic = cameraNodeMap.GetNode("Width");
            return widthPic->GetValue();
        } break;
        case Type_Basler_Height: {
            const CIntegerPtr heightPic = cameraNodeMap.GetNode("Height");
            return heightPic->GetValue();
        } break;
        default:
            return -1;
            break;
        }
    }
    
    long SBaslerCameraControl::StartAcquire()
    {
        m_isOpenAcquire = true;
        qDebug() << "SBaslerCameraControl IsGrabbing";
        try {
            qDebug() << "SBaslerCameraControl StartAcquire" << m_currentMode;
             if(m_currentMode == "Freerun")  {
                 m_basler.StartGrabbing(GrabStrategy_LatestImageOnly,GrabLoop_ProvidedByInstantCamera);
             } else if(m_currentMode == "Software") {
                 m_basler.StartGrabbing(GrabStrategy_LatestImageOnly);
                 onTimerGrabImage();
             } else if(m_currentMode == "Line1") {
                 m_basler.StartGrabbing(GrabStrategy_OneByOne);
             } else if(m_currentMode == "Line2") {
                 m_basler.StartGrabbing(GrabStrategy_OneByOne);
             }
        } catch (GenICam::GenericException &e) {
            OutputDebugString(L"StartAcquire error:");
            return -2;
        }
        return 0;
    }
    
    long SBaslerCameraControl::StopAcquire()
    {
        m_isOpenAcquire = false;
        qDebug() << "SBaslerCameraControl StopAcquire";
        try {
            if (m_basler.IsGrabbing()) {
                m_basler.StopGrabbing();
            }
        } catch (GenICam::GenericException &e) {
            OutputDebugString(LPCWSTR(e.GetDescription()));
            return -2;
        }
        return 0;
    }
    
    long SBaslerCameraControl::GrabImage(QImage &image, int timeout)
    {
        try  {
            if (!m_basler.IsGrabbing()) {
                StartAcquire();
            }
            CGrabResultPtr ptrGrabResult;
            if(m_currentMode == "Freerun")  {
            } else if(m_currentMode == "Software") {
                if (m_basler.WaitForFrameTriggerReady(1000, TimeoutHandling_Return)) {
                    m_basler.ExecuteSoftwareTrigger();
                    m_basler.RetrieveResult(timeout, ptrGrabResult,TimeoutHandling_Return);
                }
            } else if(m_currentMode == "Line1") {
                m_basler.RetrieveResult(timeout, ptrGrabResult, TimeoutHandling_Return);
            } else if(m_currentMode == "Line2") {
                m_basler.RetrieveResult(timeout, ptrGrabResult, TimeoutHandling_Return);
            }
            if (ptrGrabResult->GrabSucceeded()) {
                if (!ptrGrabResult.IsValid()) { OutputDebugString(L"GrabResult not Valid Error\n"); return -1; }
                EPixelType pixelType = ptrGrabResult->GetPixelType();
                switch (pixelType) {
                case PixelType_Mono8: {
                    CopyToImage(ptrGrabResult, image);
                } break;
                case PixelType_BayerRG8: { qDebug() << "what: PixelType_BayerRG8"; }  break;
                default:  qDebug() << "what: default"; break;
                }
            } else {
                OutputDebugString(L"Grab Error!!!");
                return -3;
            }
        } catch (GenICam::GenericException &e) {
            OutputDebugString(L"GrabImage Error\n");
            return -2;
        }  catch(...)  {
            OutputDebugString(L"ZP 11 Shot GetParam Try 12 No know Error\n");
            return -1;
        }
        return 0;
    }

    如何调用

    #ifndef MAINWINDOW_H
    #define MAINWINDOW_H
    
    #include <QMainWindow>
    #include "BaslerCamera/sbaslercameracontrol.h"
    
    namespace Ui {
    class MainWindow;
    }
    
    class MainWindow : public QMainWindow
    {
        Q_OBJECT
    
    public:
        explicit MainWindow(QWidget *parent = 0);
        ~MainWindow();
    
    private slots:
        void on_pushButton_GetExTime_clicked();
        void on_pushButton_SetExTime_clicked();
        void on_pushButton_SetMode_clicked();
        void on_pushButton_GetMode_clicked();
        void on_pushButton_CFMode_clicked();
        void on_comboBox_CFMode_activated(int index);
        void on_pushButton_Start_clicked();
        void on_pushButtonRotate_clicked();
    private:
        Ui::MainWindow *ui;
        SBaslerCameraControl* m_control = Q_NULLPTR;
        QMatrix m_matrix;
    };
    
    #endif // MAINWINDOW_H
    

    源文件:

    #include "mainwindow.h"
    #include "ui_mainwindow.h"
    #include <QDebug>
    
    MainWindow::MainWindow(QWidget *parent) :
        QMainWindow(parent),
        ui(new Ui::MainWindow)
    {
        ui->setupUi(this);
        m_control = new SBaslerCameraControl(this);
        m_control->initSome();
        connect(m_control, &SBaslerCameraControl::sigCurrentImage, [=](QImage img){
            QPixmap pix = QPixmap::fromImage(img).transformed(m_matrix);
            ui->label->setPixmap(pix);
            ui->widget_pic->setFixedSize(pix.size());
        });
        connect(m_control, &SBaslerCameraControl::sigSizeChange, [=](QSize size){
            // 默认大小641,494
            ui->label_size->setText(QString("\345\260\272\345\257\270:%0*%1").arg(QString::number(size.width())).arg(QString::number(size.height()))); // 尺寸
            ui->widget_pic->setFixedSize(size);
        });
        m_control->OpenCamera(m_control->cameras().first());
    }
    
    MainWindow::~MainWindow()
    {
        m_control->CloseCamera();
        m_control->deleteAll();
        delete ui;
    }
    
    void MainWindow::on_pushButton_GetExTime_clicked()
    {
        ui->label_exTime->setText(QString::number(m_control->getExposureTime()));
    }
    
    void MainWindow::on_pushButton_SetExTime_clicked()
    {
        m_control->setExposureTime(ui->lineEdit_exTime->text().toDouble());
    }
    
    void MainWindow::on_pushButton_SetMode_clicked()
    {
        m_control->setFeatureTriggerSourceType(ui->lineEdit_SetMode->text());
    }
    
    void MainWindow::on_pushButton_GetMode_clicked()
    {
        ui->label_Mode->setText(m_control->getFeatureTriggerSourceType());
    }
    
    void MainWindow::on_pushButton_CFMode_clicked()
    {
        ui->label_CFMode->setText(m_control->getFeatureTriggerModeType()?"Open":"Close");
    }
    
    void MainWindow::on_comboBox_CFMode_activated(int index)
    {
        m_control->setFeatureTriggerModeType(index == 0);
    }
    
    void MainWindow::on_pushButton_Start_clicked()
    {
        if(ui->pushButton_Start->text() == "\345\274\200\345\247\213\351\207\207\351\233\206") {// 开始采集
            m_control->StartAcquire();
            ui->pushButton_Start->setText("\347\273\223\346\235\237\351\207\207\351\233\206");// 结束采集
        } else {
            m_control->StopAcquire();
            ui->pushButton_Start->setText("\345\274\200\345\247\213\351\207\207\351\233\206");// 开始采集
        }
    }
    
    void MainWindow::on_pushButtonRotate_clicked()
    {
        m_matrix.rotate(90);
    }

    pro文件

    (注意:引用库文件的路径哦)

    #-------------------------------------------------
    #
    # Project created by QtCreator 2017-12-14T17:55:52
    #
    #-------------------------------------------------
    
    QT       += core gui
    
    greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
    
    TARGET = Demo_BaslerCamera
    TEMPLATE = app
    
    CONFIG   += c++11
    
    #--------------------------------------------Basler-------------------------------------------
    INCLUDEPATH += $$PWD/include
    LIBS += -L$$PWD/lib/Win32 -lGCBase_MD_VC120_v3_0_Basler_pylon_v5_0 -lGenApi_MD_VC120_v3_0_Basler_pylon_v5_0 -lPylonBase_MD_VC120_v5_0 -lPylonC_MD_VC120 -lPylonGUI_MD_VC120_v5_0 -lPylonUtility_MD_VC120_v5_0
    #----------------------------------------------------------------------------------------------
    
    SOURCES += main.cpp\
            mainwindow.cpp \
        BaslerCamera/sbaslercameracontrol.cpp
    
    HEADERS  += mainwindow.h \
        BaslerCamera/sbaslercameracontrol.h
    
    FORMS    += mainwindow.ui

     

    我把源码已经上传到码云和Github

    码云

    https://gitee.com/ShaShiDiZhuanLan/Demo_BaslerCamera

    Github

    https://github.com/ShaShiDiZhuanLan/Demo_BaslerCamera_Qt

    以上是Basler相机小Demo。如有问题直接在博客下提问,有时间的小伙伴也可以参与到项目中来……

     

    版权声明:当你的才华还撑不起你的野心时,那你就应该静下心来学习。作者:沙师弟专栏 

    原文地址:https://shazhenyu.blog.csdn.net/article/details/78844664

    展开全文
  • 工业相机仅是机器视觉系统的代表之一,在整个机器视觉系统中,光源、镜头、相机,相互制约,工业相机作为机器视觉的核心组件已得到广泛应用,那么工业相机和我们平时所用的数码相机有什么区别呢?1.工业相机可以抓拍...

    工业相机仅是机器视觉系统的代表之一,在整个机器视觉系统中,光源、镜头、相机,相互制约,工业相机作为机器视觉的核心组件已得到广泛应用,那么工业相机和我们平时所用的数码相机有什么区别呢?

    7491cb7e2304ff3b021852254df887d1.png

    1.工业相机可以抓拍快速运动的物体,因为快门时间非常短。

    举例子会更清楚一点,比如把照片贴在电风扇的扇叶上,风扇开启最大速度选择,再用工业相机抓拍,依然能够清晰看到照片里的人物或风景。但如果用一般的相机来拍摄的话,是不可能达到这样的效果。

    2.工业相机的图像传感器是逐行扫描的,一般的摄像机图像是隔行扫描。

    采用逐行扫描的图像传感器才有可能清晰的抓拍快速运动物体,逐行扫描的图像传感器生产较为困难,度申科技的相机无论是价格还是质量都是非常不错的。

    3.拍摄速度远远高于一般相机。

    一般相机只能拍摄2-3幅图像,而工业相机每秒可以拍摄十到几百幅图片,差距相差甚大。

    4.一般相机(DSC)拍摄的图片,其光谱范围只适合人眼视觉,并且经过了MPEG压缩,图像质量也较差。而工业相机输出的是裸数据,其光谱范围也往往比较宽,比较适合进行高质量的图像处理算法,普遍应用于机器视觉系统中。具备以上的技术优势,工业数字相机最终取代传统模拟相机,必将成为行业发展趋势。

    5.度申科技还提供SKD开发下载

    6.要做到长时间工作稳定性高,器件的选择要求也非常高,生产工艺要求严格。

    相信通过以上六点,大家都有初步了解工业相机和常用数码相机的不同之处了。

    展开全文
  • 在机器视觉迅猛发展的今天,工业相机作为机器视觉的核心组件已得到广泛应用,但是很多初学者还是搞不清楚究竟工业相机与普通相机有什么区别。下面小编就带大家一起去看看工业相机和普通相机的区别吧!工业相机一、...

    在机器视觉迅猛发展的今天,工业相机作为机器视觉的核心组件已得到广泛应用,但是很多初学者还是搞不清楚究竟工业相机与普通相机有什么区别。下面小编就带大家一起去看看工业相机和普通相机的区别吧!

    工业相机

    一、工业相机和普通相机的区别之性能

    工业相机的性能稳定可靠、易于安装,相机结构紧凑结实不易损坏,连续工作时间长,可在较差的环境下使用,但普通相机是做不到这些的。

    二、工业相机和普通相机的区别之快门时间

    工业相机的快门时间非常短,可以抓拍高速运动的物体。例如,把名片贴在电风扇扇叶上,以速度旋转,设置合适的快门时间,用工业相机抓拍一张图像,仍能够清晰辨别名片上的字体。用普通相机来抓拍的话,是不可能达到同样效果的。

    三、工业相机和普通相机的区别之扫描方式

    工业相机的图像传感器是逐行扫描的,而普通相机的图像传感器是隔行扫描的,逐行扫描的图像传感器生产工艺比较复杂,成品率低,出货量少,世界上只有少数公司能够提供这类产品。

    工业相机和普通相机的区别

    四、工业相机和普通相机的区别之帧率

    工业相机的帧率远远高于普通相机。工业相机每秒可以拍摄十幅到几百幅图片,而普通相机只能拍摄2-3幅图像,相差较大。

    五、工业相机和普通相机的区别之光谱范围

    工业相机输出的是裸数据,其光谱范围也往往比较宽,比较适合进行高质量的图像处理算法。而普通相机拍摄的图片,其光谱范围只适合人眼视觉,并且经过了mjpeg压缩,图像质量较差,不利于分析处理。

    六、工业相机和普通相机的区别之价格

    工业相机的性能通常都要比普通相机要好很多,所以在价格上也是要高出不少。一般工业相机的价格便宜一点都是在1500元到2000元之间,相比较好的工业相机价格可能就需要十万元以上,价格的宽度比较大。

    工业相机产品图

    以上就是齐装网小编为你分享的工业相机和普通相机的区别,希望对你有所帮助。如果想要了解更多工业相机的相关信息,请继续关注齐装网。10秒极速获取报价还能免费获取四套设计方案,更有装修管家全程跟踪服务,抓紧行动吧!

    展开全文
  • 工业相机和普通相机的区别工业相机和普通相机的区别是什么?下面是为大家精心推荐工业相机的相关知识,希望能够对您有所帮助。主要区别1、工业相机的性能强劲,稳定可靠,易于安装,相机结构紧凑结实不易损坏,连续...
  • 一、 工业相机与普通相机的区别工业相机是机器视觉系统中的一个关键组件,其最本质的功能就是将光信号转变成有序的电信号。选择合适的相机也是机器视觉系统设计中的重要环节,相机的选择不仅直接决定所采集到的图像...
  • 原标题:工业相机与普通相机有什么区别工业相机仅是机器视觉系统的代表之一。在整个机器视觉技术中,光源、镜头、相机,相互制约,但其中的关键点是摄像机。伴随相机支持技术的快速发展,特别是CCD与CMOS,他们对于...
  • 1、工业相机的性能强劲,稳定可靠,易于安装,相机结构紧凑结实不易损坏,连续工作时间长,可在较恶劣的环境下使用,一般的数码相机是做不到这些的。例如:民用数码相机无法连续长时间工作,无法快速连拍,没有安装...
  • 原标题:工业相机和普通数码相机的区别在机器视觉迅猛发展的今天,工业相机作为机器视觉的核心组件已得到广泛应用,但是很多初学者还是搞不清楚究竟工业相机与我们平时所用的数码相机有什么区别,现在轩展科技小编就...
  • 附注:任何东西分类一定有它自己的分类标准,工业相机也不例外,按照芯片类型可以分为CCD相机、CMOS相机;按照传感器的结构特性可以分为线阵相机、面阵相机;按照扫描方式可以分为隔行扫描相机、逐行扫描相机;按照...
  • 高速相机是工业相机的一种,一般高速相机指的是数字工业相机,其一般安装在机器流水线上代替人眼来做测量和判断,通过数字图像摄取目标转换成图像信号,传送给专用的图像处理系统。 高速相机,相比起普通相机,高速...
  • 文章来源:https://blog.csdn.net/snwang_miss/article/details/55253577一、 工业相机与普通相机的区别工业相机是机器视觉系统中的一个关键组件,其最本质的功能就是将光信号转变成有序的电信号。选择合适的相机也...
  • 原标题:工业相机和普通相机有什么不同?工业相机和普通相机有什么不同呢?其实不管是从外观还是性能上面,都是有天壤之别。因为工业相机本身应用于工业自动化设备上面,其要求工业性能、工业稳定性、工业分辨率都要...
  • 展开全部1、工业相机的性能强劲,稳定可靠,易于安装,相机结构紧凑结实不易损坏,e68a8462616964757a686964616f31333365643635连续工作时间长,可在较恶劣的环境下使用,一般的数码相机是做不到这些的。例如:民用...
  • 随着我国科技的迅速发展,越来越多的新型产品开始出现在消费者的视野中,在为我们生活带来便利的同时也带动了相关行业的发展。扫描检测设备作为日常生活中使用频率较高的设备之一,其发展动态...面阵工业相机和线阵...
  • 工业相机选型解密之相机接口
  • 工业相机和普通相机有什么区别呢?其实不管是从外观还是性能上面,都是有天壤之别。因为工业相机本身应用于工业自动化设备上面,其要求工业性能、工业稳定性、工业分辨率都要远远高于普通数码相机。具体的区别,亚米...
  • 工业相机之相机分类

    2020-07-23 16:24:22
    工业相机作为机器视觉系统重要组成部分,首先需要确定的就是相机的类型。下面就带大家了解一下常见工业相机的分类。 一、模拟相机与数字相机        工业相机按输出图像信号格式划分为模拟...
  • 一、相机介绍及选型方法工业相机介绍 工业相机与我们手机上面的相机或者我们单反相机不同,工业相机它能够使用各种恶劣的工作环境,比如说高温,高压,高尘等。工业相机主要有面阵相机和线阵相机,线阵相机主要用于...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,023
精华内容 1,209
关键字:

工业相机