OpenCV矩阵可视化工具包

最新推荐文章于 2024-02-29 20:18:12 发布
最新推荐文章于 2024-02-29 20:18:12 发布
阅读量474 收藏
点赞数
文章标签： 人工智能 开发工具 数据结构与算法
原文链接：http://www.cnblogs.com/easymind223/archive/2013/03/31/2991866.html
版权

在用opencv编程时，经常需要可视化地查看某个矩阵在运算过程中的状态如何，而opencv中的imshow函数只能以灰度显示单通道uchar或float类型的图像，其可视化效果不尽人意，为此，我写了一个矩阵可视化工具包，其中包含了一个类似于matlab中的imagesc的函数，能够以不同的颜色显示矩阵中不同大小的值，这个函数在查看矩阵时非常方便，这里贡大家参考。

VisualizationTool.h

View Code 
//http://www.cnblogs.com/easymind223


#pragma once
#ifndef _VISUALIZATION_TOOL_H_
#define _VISUALIZATION_TOOL_H_

#include "opencv2/opencv.hpp"

#define HIST_TYPE_MIX 0
#define HIST_TYPE_CONTOUR 1

namespace VisualizationTool
{

//深度显示单通道uchar,float, int类型图像，
void imageSC(std::string windowName, const cv::Mat imgC1);

//以柱状图显示数组，array必须为 CV_32F,CV_32S,CV_8U中的一种，且rows == 1
void ShowArrayHistogram(std::string title, cv::Mat array, cv::Size size = cv::Size(400,400));

//显示一幅图像的直方图，histType为显示方式，HIST_TYPE_MIX表示三通道混合显示，HIST_TYPE_CONTOUR表示以轮廓显示
void showImageHistogram(const std::string windowName, const cv::Mat src, 
    const cv::Mat mask = cv::Mat(), int histType = HIST_TYPE_MIX, 
    cv::Size windowSize = cv::Size(256, 200));

//显示一幅图像的颜色分布图
void showImageColorDistribution(const std::string windowName, const cv::Mat src_3u,
    int nBins = 32, const cv::Mat mask = cv::Mat(), cv::Size windowSize = cv::Size(256, 200));

}
#endif

VisualizationTool.cpp

View Code 
#include "stdafx.h"
#include "VisualizationTool.h"

namespace VisualizationTool
{

void imageSC(std::string windowName, const cv::Mat imgC1)
{
    assert(imgC1.channels() == 1 && !imgC1.empty());

    //get min max value of the mat
    double minPixelValue, maxPixelValue;
    cv::minMaxIdx(imgC1, &minPixelValue, &maxPixelValue);
    double valueRange = maxPixelValue - minPixelValue;

    //init color table
    const int minSaturation = 20;
    const int colorTableLength = (255 - minSaturation) * 4;    // r -> g -> b
    cv::Scalar colorTable[colorTableLength];

    int i,j;
    for (i = 0, j = minSaturation; i < colorTableLength / 4; i++, j++)
        colorTable[i] = CV_RGB(255, j, minSaturation);
    for (i = colorTableLength / 4, j=1; i < colorTableLength / 2; i++, j++)
        colorTable[i] = CV_RGB(255 - j, 255, minSaturation);
    for (i = colorTableLength/2, j=minSaturation; i < colorTableLength/4*3; i++, j++)
        colorTable[i] = CV_RGB(minSaturation, 255, j);
    for (i = colorTableLength/4*3, j=1; i < colorTableLength; i++, j++)
        colorTable[i] = CV_RGB(minSaturation, 255 - j, 255);


    //draw color table
    const int margin = 20;
    const int tableHeight = 300;;
    const int tableWidth = 150;
    const int barWidth = 30;
    const int barHeight = tableHeight - margin * 2;
    float scale = (float)barHeight / colorTableLength;

    int imageHeight = cv::max(imgC1.rows, tableHeight);
    int imageWidth = imgC1.cols + tableWidth;
    cv::Mat img3u( imageHeight, imageWidth, CV_8UC3, cv::Scalar::all(0));

    for (int i=0; i<barHeight; i++)
    {
        cv::Point pt1(imgC1.cols + margin, margin + i);
        cv::Point pt2(imgC1.cols + margin + barWidth, margin + i);
        cv::line(img3u, pt1, pt2, colorTable[cvRound(i/scale)], 1);
    }

    //illustration
    for (int i=0; i<5; i++)
    {
        float value = minPixelValue + i / 4.0 * valueRange;
        std::stringstream s;
        s<<value;
        int bx = imgC1.cols + margin + barWidth;
        int by = tableHeight - margin - barHeight / 4 * i ;
        cv::line(img3u, cv::Point(bx+5, by), cv::Point(bx+10, by), cvScalarAll(255), 2);
        cv::putText(img3u, s.str(), cv::Point(bx + 20, by + 8),
            CV_FONT_HERSHEY_SIMPLEX, 0.6, cvScalarAll(255), 1);
    }

    //show image
    cv::Mat tim(imgC1.size(), CV_32F);
    imgC1.convertTo(tim, CV_32F);

    for (int y = 0; y < imgC1.rows; y++)
    {
        const float* srcData = tim.ptr<float>(y);
        cv::Vec3b* dstData = img3u.ptr<cv::Vec3b>(y);
        for (int x = 0; x<imgC1.cols; x++)
        {
            double pixel = (srcData[x] - minPixelValue) / valueRange;
            cv::Scalar color = colorTable[cvRound(pixel * (colorTableLength-1))];
            dstData[x] =cv::Vec3b(color.val[2], color.val[1], color.val[0]);
        }
    }
    cv::imshow(windowName, img3u);
}

void ShowArrayHistogram(std::string title, cv::Mat hist, cv::Size size)
{
    CV_Assert(hist.rows == 1);
    cv::Mat imHist = cv::Mat::zeros(size, CV_8UC3);
    int nBins = hist.rows*hist.cols;
    double min, max;
    cv::minMaxLoc(hist, &min, &max);
    double bin_width=(double)size.width/nBins;  
    double bin_unith=(double)size.height/max;

    if(hist.type() == CV_32F)
    {
        float * ptr = hist.ptr<float>(0);
        for(int i=0;i<nBins;i++)  
        {  
            cv::Point p0=cv::Point(i*bin_width,size.height);  
            cv::Point p1=cv::Point((i+1)*bin_width,size.height-ptr[i]*bin_unith);  
            cv::rectangle(imHist, p0, p1, cv::Scalar::all(255), -1, 0, 0);
        } 
    }
    if(hist.type() == CV_32S)
    {
        int* ptr = hist.ptr<int>(0);
        for(int i=0;i<nBins;i++)  
        {  
            cv::Point p0=cv::Point(i*bin_width,size.height);  
            cv::Point p1=cv::Point((i+1)*bin_width,size.height-ptr[i]*bin_unith);  
            cv::rectangle(imHist, p0, p1, cv::Scalar::all(255), -1, 0, 0);
        } 
    }
    if(hist.type() == CV_8U)
    {
        uchar* ptr = hist.ptr<uchar>(0);
        for(int i=0;i<nBins;i++)  
        {  
            cv::Point p0=cv::Point(i*bin_width,size.height);  
            cv::Point p1=cv::Point((i+1)*bin_width,size.height-ptr[i]*bin_unith);  
            cv::rectangle(imHist, p0, p1, cv::Scalar::all(255), -1, 0, 0);
        } 
    }

    cv::namedWindow(title);
    cv::imshow(title, imHist);
}

void showImageHistogram(const std::string windowName, const cv::Mat src,  const cv::Mat mask, int histType, cv::Size windowSize)
{
    CV_Assert(!src.empty());
    if (!mask.empty())
    {
        CV_Assert(mask.type() == CV_8U && src.size() == mask.size());
    }

    cv::Mat src_3u;
    if(src.channels()==1)
        cv::cvtColor(src, src_3u, CV_GRAY2RGB);
    else
        src_3u = src;

    //shrink the src to save time
    float th_maxSide = 300.0;
    int maxSide = cv::max(src_3u.cols , src_3u.rows);
    cv::Mat zoom_3u, zoomMask_1u;

    if (maxSide > th_maxSide)
    {
        float scale = maxSide / th_maxSide;
        zoom_3u.create(src_3u.rows / scale, src_3u.cols / scale, CV_8UC3);
        cv::resize(src_3u, zoom_3u, zoom_3u.size(), 0, 0, cv::INTER_LANCZOS4 );

        if(!mask.empty())
        {
            zoomMask_1u.create(mask.rows / scale, mask.cols / scale, CV_8U);
            cv::resize(mask, zoomMask_1u, zoomMask_1u.size(), 0, 0, cv::INTER_LANCZOS4 );
        }
    }
    else
    {
        zoom_3u = src_3u;
        if(!mask.empty())
            zoomMask_1u = mask;
    }

    std::vector<cv::Mat> rgb_planes;
    cv::split(zoom_3u, rgb_planes );

    int nBins = 255;

    /// 设定取值范围 ( R,G,B) )
    float range[] = { 0, 256 } ;
    const float* histRange = { range };

    bool uniform = true; bool accumulate = false;

    cv::Mat r_hist, g_hist, b_hist;

    /// 计算直方图:
    cv::calcHist( &rgb_planes[0], 1, 0, zoomMask_1u, r_hist, 1, &nBins, &histRange, uniform, accumulate );
    cv::calcHist( &rgb_planes[1], 1, 0, zoomMask_1u, g_hist, 1, &nBins, &histRange, uniform, accumulate );
    cv::calcHist( &rgb_planes[2], 1, 0, zoomMask_1u, b_hist, 1, &nBins, &histRange, uniform, accumulate );

    // 创建直方图画布
    int canvasWidth = windowSize.width; 
    int canvasHeight = windowSize.height;
    int binWidth = cvRound( (double) canvasWidth / nBins );

    cv::Mat histImage(canvasHeight, canvasWidth,  CV_8UC3, cv::Scalar( 0,0,0) );

    /// 将直方图归一化到范围 [ 0, histImage.rows ]
    cv::normalize(r_hist, r_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat() );
    cv::normalize(g_hist, g_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat() );
    cv::normalize(b_hist, b_hist, 0, histImage.rows, cv::NORM_MINMAX, -1, cv::Mat() );

    /// 在直方图画布上画出直方图
    if (histType == HIST_TYPE_CONTOUR)
    {
        for( int i = 1; i < nBins; i++ )
        {
            cv::line( histImage, cv::Point( binWidth*(i-1), canvasHeight - cvRound(r_hist.at<float>(i-1)) ) ,
                cv::Point( binWidth*(i), canvasHeight - cvRound(r_hist.at<float>(i)) ),
                cv::Scalar(255, 0, 0), 2, 8, 0  );
            cv::line( histImage, cv::Point( binWidth*(i-1), canvasHeight - cvRound(g_hist.at<float>(i-1)) ) ,
                cv::Point( binWidth*(i), canvasHeight - cvRound(g_hist.at<float>(i)) ),
                cv::Scalar( 0, 255, 0), 2, 8, 0  );
            cv::line( histImage, cv::Point( binWidth*(i-1), canvasHeight - cvRound(b_hist.at<float>(i-1)) ) ,
                cv::Point( binWidth*(i), canvasHeight - cvRound(b_hist.at<float>(i)) ),
                cv::Scalar( 0, 0, 255), 2, 8, 0  );
        }
    }
    else if (histType == HIST_TYPE_MIX)
    {
        for (int iBin=0; iBin<nBins; iBin++)
        {
            for (int iValue=1; iValue < r_hist.at<float>(iBin); iValue++)
            {
                for (int j=0; j<binWidth; j++)
                {
                    cv::Vec3b& pixel = histImage.at<cv::Vec3b>(canvasHeight - iValue, iBin * binWidth + j);
                    pixel.val[0] = 255;
                }
            }
            for (int iValue=1; iValue < g_hist.at<float>(iBin); iValue++)
            {
                for (int j=0; j<binWidth; j++)
                {
                    cv::Vec3b& pixel = histImage.at<cv::Vec3b>(canvasHeight - iValue, iBin * binWidth + j);
                    pixel.val[1] = 255;
                }
            }
            for (int iValue=1; iValue < b_hist.at<float>(iBin); iValue++)
            {
                for (int j=0; j<binWidth; j++)
                {
                    cv::Vec3b& pixel = histImage.at<cv::Vec3b>(canvasHeight - iValue, iBin * binWidth + j);
                    pixel.val[2] = 255;
                }
            }
        }
    }
    cv::imshow(windowName, histImage );    
}

bool histCompare(std::pair<cv::Scalar,int> v1, std::pair<cv::Scalar,int> v2)
{
    return v1.second < v2.second;
}

int countValueAppearTimes(const cv::Mat srcC1, double value)
{
    CV_Assert(!srcC1.empty() && srcC1.channels()==1);

    cv::Mat r = srcC1 - value;
    int times = cv::countNonZero(r);
    return srcC1.cols * srcC1.rows - times;
}

void showImageColorDistribution(const std::string windowName, const cv::Mat src_3u, int nBins, 
    const cv::Mat mask, cv::Size windowSize)
{
    CV_Assert(!src_3u.empty() );
    if (!mask.empty())
    {
        CV_Assert(mask.type() == CV_8U && src_3u.size() == mask.size());
    }

    //shrink the src to save time
    float th_maxSide = 300.0;
    int maxSide = cv::max(src_3u.cols , src_3u.rows);
    cv::Mat zoom_3u, zoomMask_1u;

    if (maxSide > th_maxSide)
    {
        float scale = maxSide / th_maxSide;
        zoom_3u.create(src_3u.rows / scale, src_3u.cols / scale, CV_8UC3);
        cv::resize(src_3u, zoom_3u, zoom_3u.size(), 0, 0, cv::INTER_LANCZOS4 );

        if(!mask.empty())
        {
            zoomMask_1u.create(mask.rows / scale, mask.cols / scale, CV_8U);
            cv::resize(mask, zoomMask_1u, zoomMask_1u.size(), 0, 0, cv::INTER_LANCZOS4 );
        }
    }
    else
    {
        zoom_3u = src_3u;
        if(!mask.empty())
            zoomMask_1u = mask;
    }
    int maskNonZero = countNonZero(zoomMask_1u);

    //k-means cluster
    cv::Mat clusterMat;
    cv::Mat bestLabels, centers;
    cv::Vec3b* data = zoom_3u.ptr<cv::Vec3b>(0);
    if(mask.empty())
    {
        clusterMat.create(zoom_3u.cols * zoom_3u.rows, 3, CV_32F);
        for (int i=0; i<zoom_3u.cols * zoom_3u.rows; i++)
        {
            cv::Vec3b pixel = data[i];
            clusterMat.at<float>(i, 0) = pixel.val[0];
            clusterMat.at<float>(i, 1) = pixel.val[1];
            clusterMat.at<float>(i, 2) = pixel.val[2];
        }
    }
    else
    {
        clusterMat.create(maskNonZero, 3, CV_32F);
        const uchar* maskData = zoomMask_1u.ptr<uchar>(0);
        for (int i=0, j=0; i<zoomMask_1u.cols * zoomMask_1u.rows; i++)
        {
            if(maskData[i] > 0)
            {
                cv::Vec3b pixel = data[i];
                clusterMat.at<float>(j, 0) = pixel.val[0];
                clusterMat.at<float>(j, 1) = pixel.val[1];
                clusterMat.at<float>(j, 2) = pixel.val[2];
                j++;
            }
        }
    }

    cv::kmeans(clusterMat, nBins, bestLabels, cv::TermCriteria( CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, 10, 1.0),
        3, cv::KMEANS_PP_CENTERS, centers);

    //statistics
    std::vector<std::pair<cv::Scalar,int>> hist(nBins);
    for (int i=0; i<nBins; i++)
    {
        cv::Scalar color( centers.at<float>(i,0), centers.at<float>(i,1), centers.at<float>(i,2));
        int val = countValueAppearTimes(bestLabels, i);
        hist.at(i) = std::pair<cv::Scalar,int>(color, val);
    }
    std::sort(hist.begin(), hist.end(), histCompare);
    int maxValue = hist[nBins-1].second;

    //canvas
    float scale = (float)windowSize.height / maxValue;
    int binWidth = windowSize.width / nBins;
    cv::Mat canvas(windowSize, CV_8UC3, cv::Scalar::all(30));

    for (int i=0; i<nBins; i++)
    {
        cv::Point pt1(  i    * binWidth, canvas.rows - 1);
        cv::Point pt2( (i+1) * binWidth, canvas.rows - 1 - hist[i].second * scale);        
        cv::rectangle(canvas, pt1, pt2, hist[i].first, -1);
    }
    cv::imshow(windowName, canvas);
}

}

  注意：由于博客园的bug, cpp文件中的kmeans函数会复制不全，复制以后可能会少一个参数，请仔细检查

解释一下文件中的几个函数：

1. void imageSC(std::string windowName, const cv::Mat imgC1)

深度显示单通道uchar,float, int类型图像，类似于matlab的imagesc函数，本函数还自带颜色表和矩阵的值域分布

例：

 

2. void showImageHistogram(const std::string windowName, const cv::Mat src, const cv::Mat mask = cv::Mat(), int histType = HIST_TYPE_MIX, cv::Size windowSize = cv::Size(256, 200));

显示一幅图像的直方图，histType为显示方式，HIST_TYPE_MIX表示三通道混合显示，HIST_TYPE_CONTOUR表示以轮廓显示，窗口的宽度最好是256的倍数。

例：

 

3.void showImageColorDistribution(const std::string windowName, const cv::Mat src_3u, int nBins = 32, const cv::Mat mask = cv::Mat(), cv::Size windowSize = cv::Size(256, 200));

显示一幅图像的颜色分布图，这个函数有点慢，结果也有一定的不确定性，因为用到了k-means,函数的速度取决于nBins的大小，窗口的宽度最好是256的倍数。

例：

 

 

4. void ShowArrayHistogram(std::string title, cv::Mat array, cv::Size size = cv::Size(400,400));

以柱状图显示一维数组，array必须为 CV_32F,CV_32S,CV_8U中的一种，且rows == 1，这个函数就不贴图了~

转载于:https://www.cnblogs.com/easymind223/archive/2013/03/31/2991866.html

weixin_34087301
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
OpenCV实现halcon卡尺工具
06-10
基于OpenCV实现，仿Halcon卡尺工具
opencv的RGB 颜色表
Vertira的博客
01-13 1万+
RGB（255,23,140）是光的三原色，也即是红绿蓝Red，Green，Blue，它们的最大值是255，相当于100%。 白色：rgb(255,255,255) 黑色：rgb(0,0,0) 红色：rgb(255,0,0) 绿色：rgb(0,255,0) 蓝色：rgb(0,0,255) 青色：rgb(0,255,255) 紫色：rgb(255,0,255) ...
Opencv C++ 图像像素操作
weixin_43965740的博客
01-16 798
使用image.converTo(dst,type)对图像进行类型转换。image.at(x,y)[i]读取三通道图像的像素值。image.at(x,y)读取单通道图像的像素值。在执行像素操作之前，我们需要读取图像的宽、高、通道数;获取图像的通道数：image.channels()获取浮点类型（Vec3f）三通道像素值。CV_8UC1为单通道uchar类型。CV32F1 为单通道float类型。获取图像的宽：image.cols。获取图像的高：image.rows。
用OPENCV,C++实现直线卡尺工具原理，一步到位
最新发布
weixin_45416828的博客
02-29 1226
用OPENCV，c++实现卡尺工具原理
使用OpenCV工具包成功实现人脸检测与人脸识别，包括传统视觉和深度学习方法（附完整代码，模型下载......）
热门推荐
分享技术笔记，记录学习研发历程
06-30 1万+
使用OpenCV自带的人脸检测和人脸识别方法成功实现传统视觉和深度学习两种方式的效果，并进行了对比，应该是全网最全的整理了
OpenCV图像可视化工具Image Watch
Xu_Haocan的博客
09-28 2147
参考链接
OpenCV直方图的原理与显示、掩膜、均衡化、自适应均衡化
qq_53545309的博客
09-23 541
OpenCV直方图的原理与显示、掩膜、均衡化、自适应均衡化
Python-通过opencvpython可视化几种著名的排序算法
08-10
通过opencv-python可视化几种著名的排序算法
openCV4.5.5jar包
04-10
openCV4.5.5jar包
OpenCvSharp调试图片可视化插件-OpenCvSharp.DebuggerVisualizers-v4.7-VS2022
07-04
OpenCvSharp 调试图片可视化插件_OpenCvSharp.DebuggerVisualizers_v4.7_VS2022 Mat 图可视化。
OpenCvSharp二值化工具.rar
07-26
OpenCvSharp二值化工具.rar C# OpenCvSharper 二值化工具 阈值 自适应阈值 局部阈值 InRange 项目： VS2010+.net4.0+OpenCvSharper3 博客地址： https://blog.csdn.net/lw112190/article/details/131937835
VS+QT+Opencv可视化编程
12-22
VS+QT+Opencv可视化编程，包含环境搭建和简单的opencv vs2013 qt结合的可视化编程。
【OpenCV实现图像：可视化目标检测框】
weixin_47869094的博客
11-23 3213
通过使用Python和相关的图像处理库，可以轻松实现目标检测框的可视化。通过结合目标检测算法的输出和Matplotlib的功能，可以创建一个直观且易于理解的图像，展示图像中目标的位置和边界框。通过cv2.rectangle 函数设置 thickness参数 ,可以得到填充后的图像,进而利用opencv中的 cv2.add_weight 函数可以实现透明效果，自行尝试。左上为常用的不带标签的输出框,右上为YOLO系列美化带标签后的矩形框,左下为四个角点美化后的矩形框,右下为带标签的角点美化矩形框.
关于 OpenCV 图像处理工具包 imutils 简单认知
山河已无恙
05-27 1119
博文内容涉及 基本的图像处理工具包 imutils 的简单介绍以及使用Demo理解不足小伙伴帮忙指正对每个人而言，真正的职责只有一个：找到自我。然后在心中坚守其一生，全心全意，永不停息。所有其它的路都是不完整的，是人的逃避方式，是对大众理想的懦弱回归，是随波逐流，是对内心的恐惧 ——赫尔曼·黑塞《德米安》imutils是一个基于 OpenCV 的 Python 图像处理库。它包含了许多函数来简化常见的操作，如调整大小、旋转和显示图像等。调整图像大小并保持纵横比以指定角度旋转图像。
OpenCV之AI工具包介绍(OAK-1和OAK-D)
深度学习与计算机视觉
03-17 3129
这个小工具适用于不断发展的计算机视觉和三维感知领域，它将许多功能集成到一个小单元中。我开始探索OpenCV AI Kit D（OAK-D）是因为OpenCV AI的竞赛。这是一个庆祝Ope...
visual studio2019安装opencv可视化工具image watch
诺有缸的高飞鸟的博客
05-15 1751
目录内容配置安装扩展使用完 转载本文请注明出处，本文链接：https://blog.csdn.net/qq_41102371/article/details/116862557 内容 visual studio2019安装opencv可视化工具image watch，有时候需要在调试的时候查看mat，image watch是一个很好地选择，可以查看每个元素并且能显示多维的矩阵 配置 win10+vs2019+opencv440: vs2019配置opencv+contrib-440 + PCL1.10.0
opencv_cvv交互式计算机视觉可视化debug工具的使用
Liber-coder的博客
05-24 2782
本文介绍cvv模块的安装和使用。 cvv，官网称之为“GUI for Interactive Visual Debugging of Computer Vision”，即交互式计算机视觉可视化debug工具，我对其很感兴趣，但是我在网上几乎没见到关于cvv的介绍，因此自行摸索了一番，有了本文。
LabVIEW AI视觉工具包OpenCV Mat基本用法和属性
virobotics的博客
04-01 1348
LabVIEW AI视觉工具包OpenCV Mat基本用法和属性
C++ opencv viz位姿可视化
m0_66692708的博客
11-19 1799
用C++ opencv viz可视化相机相对位姿
c++opencv3.1依赖包
10-06
在使用 OpenCV 3.1 时，需要安装一些依赖包来保证其正常运行。下面是一些常见的依赖包： 1. 编译工具：安装编译 C++ 的工具，如CMake 和 GCC。CMake 用于构建和生成 Makefile，GCC 用于编译源代码。 2. 图形库：OpenCV 3.1 依赖于一些图形库，如 GTK+，OpenGL 和 Qt。这些库用于图像显示、用户界面和可视化等功能。 3. 矩阵运算库：OpenCV 使用了一些矩阵和线性代数操作，因此需要安装 BLAS（Basic Linear Algebra Subprograms）或者 LAPACK（Linear Algebra Package）。 4. 图像 I/O 库：用于读取和写入图像文件的库，如 libjpeg、libpng、libtiff、libjasper 等。安装这些库可确保 OpenCV 能够处理各种图像格式。 5. 数据库支持：如果需要使用 OpenCV 中的数据库模块，需要安装一些数据库驱动程序，如 MySQL 或 SQLite。 这些依赖包的具体安装方法会根据你所使用的操作系统而有所不同。一般而言，你可以通过包管理器来安装这些依赖包，如在 Ubuntu 上，可以使用 apt-get 命令进行安装。 通过安装这些依赖包，你可以确保 OpenCV 3.1 在你的系统上能够正常编译和运行，同时也能够支持更多的功能和图像格式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值