精华内容
下载资源
问答
  • ②利用Opencv改变图片分辨率(默认是缩小为原来一般的分辨率)并显示在mfc对话框一个图片控件中。 ③保存。对话框有一个保存按钮。用于保存更改了分辨率之后的图片。(对于更改了之后的图片。又可以再次执行相同的...
  • python opencv批量修改图片分辨率

    千次阅读 2019-10-17 19:53:29
    python opencv批量修改图片分辨率 跑了一个模型,好像因为图片分辨率太高内存不够跑不了,修改了下果然能跑了! import cv2 import os if __name__ == '__main__': curDir = os.curdir # 获取当前执行python文件...

    python opencv批量修改图片分辨率

    跑了一个模型,好像因为图片分辨率太高内存不够跑不了,修改了下果然能跑了!

    import cv2
    import os
    
    if __name__ == '__main__':
    
        curDir = os.curdir  # 获取当前执行python文件的文件夹
        sourceDir = os.path.join(curDir, 'pic')
        resultDir = os.path.join(curDir, 'result')
    
        img_list = os.listdir(sourceDir)
    
        for i in img_list:
            pic = cv2.imread(os.path.join(sourceDir, i), cv2.IMREAD_COLOR)
            pic_n = cv2.resize(pic, (481, 321))
            pic_name = i
            cv2.imwrite(os.path.join(resultDir, i), pic_n)
    
    

    嗯,很简单的代码。。

    展开全文
  • 要将100多张1920*1280分辨率的图片分辨率调整到1280*720分辨率 首先需要安装opencv ···shell pip install opencv ··· 然后修改图片分辨率 import cv2 import os curDir = os.curdir # 获取当前执行python文件...

    示例:opencv批量降低图片分辨率

    要将100多张1920*1280分辨率的图片分辨率调整到1280*720分辨率
    首先需要安装opencv

    pip install opencv-python
    

    然后修改图片分辨率

    import cv2
    import os
    
    curDir = os.curdir  # 获取当前执行python文件的文件夹
    sourceDir = os.path.join(curDir, 'picture')
    resultDir = os.path.join(curDir, 'resolution_lower')
    
    def resolution_lower_handler(sourceDir, resultDir):
        img_list = os.listdir(sourceDir)
    
        for i in img_list:
            pic = cv2.imread(os.path.join(sourceDir, i), cv2.IMREAD_COLOR)
            pic_n = cv2.resize(pic, (1280, 720))
            pic_name = i
            cv2.imwrite(os.path.join(resultDir, i), pic_n)
    
    if __name__ == '__main__':
        resolution_lower_handler(sourceDir, resultDir)
    

    这样就可以降低分辨率了

    展开全文
  • Python OpenCV设置摄像头分辨率

    千次阅读 2019-12-02 21:06:13
    OpenCV是我们常用的一款优质图形库,那么如何使用OpenCV设置摄像头的分辨率呢?博主经过在Linux及Windows试验,发现了一些有趣的东西。

    在创建完 VideoCapture 对象并成功打开摄像头后,可以使用函数 video.get(propId) 来获得视频的一些参数信息。这里propId 可以是 0 到 18 之间的任何整数。每一个数代表视频的一个属性,详情可以见下表。与get方法对应的就是set方法,因此其中的一些值可以使用video.set(propId, value) 来修改,value 就是你想要设置成的新值。查看摄像头的分辨率可以使用 video.shape 函数,其中前两个值分别是高、宽值。除此常用方法外,还可以使用 video.get(3)video.get(4),前者对应摄像头的宽,后者对应高。默认情况下,摄像头的分辨率的为:640X480,我们可以使用set方法对其修改,如改为320X240: video.set(3, 320), video(4, 240)

    方法释义
    cv2.VideoCapture.get(0)视频文件的当前位置(播放)以毫秒为单位
    cv2.VideoCapture.get(1)基于以0开始的被捕获或解码的帧索引
    cv2.VideoCapture.get(2)视频文件的相对位置(播放):0=电影开始,1=影片的结尾。
    cv2.VideoCapture.get(3)在视频流的帧的宽度
    cv2.VideoCapture.get(4)在视频流的帧的高度
    cv2.VideoCapture.get(5)帧速率
    cv2.VideoCapture.get(6)编解码的4字-字符代码
    cv2.VideoCapture.get(7)视频文件中的帧数
    cv2.VideoCapture.get(8)返回对象的格式
    cv2.VideoCapture.get(9)返回后端特定的值,该值指示当前捕获模式
    cv2.VideoCapture.get(10)图像的亮度(仅适用于照相机)
    cv2.VideoCapture.get(11)图像的对比度(仅适用于照相机)
    cv2.VideoCapture.get(12)图像的饱和度(仅适用于照相机)
    cv2.VideoCapture.get(13)色调图像(仅适用于照相机)
    cv2.VideoCapture.get(14)图像增益(仅适用于照相机)(Gain在摄影中表示白平衡提升)
    cv2.VideoCapture.get(15)曝光(仅适用于照相机)
    cv2.VideoCapture.get(16)指示是否应将图像转换为RGB布尔标志
    cv2.VideoCapture.get(17)× 暂时不支持
    cv2.VideoCapture.get(18)立体摄像机的矫正标注(目前只有DC1394 v.2.x后端支持这个功能)

    下面是一个完整的设置摄像头分辨率的demo (以下两种设置方式均可):

    import cv2
    
    if __name__ == "__main__":
        webcam = cv2.VideoCapture(0)
        
        if not webcam.isOpened():
            print("can't open the camera!!!")
        # cv2.namedWindow("video", 0)
        # cv2.resizeWindow("video", 960, 720)
        # method 1:
        webcam.set(3, 1920)  # width=1920
        webcam.set(4, 1080)  # height=1080
        # method 2:
        # webcam.set(cv2.CAP_PROP_FRAME_WIDTH, 960)
        # webcam.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)
        while True:
            ret, frame = webcam.read()
            print(frame.shape[:2])  # just need the first two values.
            cv2.imshow("video", frame)
            # Hit 'q' on the keyboard to quit!
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
    
        # Release handle to the webcam
        webcam.release()
        cv2.destroyAllWindows()
    

    下面有趣的东西来了!!!
    在 Windows 中,以上方法可以成功改变摄像头的分辨率,即如上代码中将分辨率设置为:1920X1080,但是在Linux(博主测试了Ubuntu16.04及Ubuntu18.04)中,上面的方法却不完全成功,分辨率的确改变了,但是却改为了:800X600,即最大分辨率为:800X600。(注: 博主只是发现了这一现象,却没搞懂其中原理,如有大牛看到此问题,请不吝赐教)

    -------------------------------------------------------------手动分割线-------------------------------------------------------------------


    以下方法可以用来改变窗口的显示大小,但是不等于摄像头的分辨率。(不相信的伙伴可以自己试试)

    cv2.namedWindow("video", 0)  # 0 即 cv2.WINDOW_NORMAL,表示可以自己调整窗口大小。注意:此“winname”参数应与后面的inshow()中一致。
    cv2.resizeWindow("video", 960, 720)  # 修改窗口大小为960X720
    

    参考文献

    展开全文
  • 简介 超分辨率是指对图像细节进行放大或改进的过程。当增加图像的尺寸时,额外的像素需要以某种方式...1.OpenCV的超分辨率 用于图像的缩放,OpenCV目前有四种深度学习算法供选择。在本文中,我们将对所有这些方法进行回

    简介

    超分辨率是指对图像细节进行放大或改进的过程。当增加图像的尺寸时,额外的像素需要以某种方式进行插值。传统的图像处理技术并不能得到好的结果,因为它们在放大时没有把周围环境作为背景。深度学习和最近的GANs在这里发挥了作用,提供了更好的结果。

    下面给出的图像说明了超分辨率。放大后,原来的高分辨率图像显示出了最好的细节。其他图像采用各种超分辨率方法重建后得到。你可以在这里读到更多细节。
    在这里插入图片描述

    1.OpenCV的超分辨率

    用于图像的缩放,OpenCV目前有四种深度学习算法供选择。在本文中,我们将对所有这些方法进行回顾。我们还将看到它们的结果,并将它们与使用OpenCV中双三次插值方法进行缩放的图像进行比较。我们将讨论的四种方法是(1)EDSR Model(2)ESPCN Model(3)FSRCNN Model(4)LapSRN Model
    请注意,前三个算法提供了2、3和4倍的比率,而最后一个算法有2、4和8倍的原始大小!每个所需比率的TensorFlow模型可以通过上面提供的链接下载。

    为了使用上面列出的模型实现超分辨率,我们需要使用标准OpenCV模块之外的功能。这就是为什么我们也必须安装opencv-contrib模块的原因。此外,超分辨率出现在模块dnn_superres(基于深度神经网络的超分辨率)中,该模块在C++的OpenCV4.1版本和Python的OpenCV4.3版本中实现。

    注意:如果你已经安装了OpenCV,最好创建一个虚拟环境并在其中安装OpenCV-contrib,以避免任何依赖问题。默认情况下,这将安装最新版本的OpenCV以及OpenCV-contrib模块。如果您在运行此命令之前已经安装了OpenCV,您也可以选择卸载它。
    代码地址:

    链接:https://pan.baidu.com/s/1M0l63vxYbS7zrF3Pn9IYaQ 
    提取码:123a
    

    为了比较上述算法,我们将使用以下图片作为参考。
    在这里插入图片描述

    (1)Python

    import cv2
    import matplotlib.pyplot as plt
    # 读取图片
    img = cv2.imread("AI-Courses-By-OpenCV-Github.png")
    plt.imshow(img[:,:,::-1])
    plt.show()
    # 裁剪OpenCV标识
    img = img[5:60,700:755]
    plt.imshow(img[:,:,::-1])
    plt.show()
    

    在这里插入图片描述在这里插入图片描述

    我们首先导入opencvmatplotlib并读取测试图片。为了裁剪OpenCV标识,我们使用上面给出的代码。
    (2)C++

    #include <iostream>
    #include <fstream>
    #include <opencv2/opencv.hpp>
    #include <opencv2/dnn_superres.hpp>
    
    using namespace std;
    using namespace cv;
    using namespace dnn;
    
    // 读取图片
    Mat img = imread("AI-Courses-By-OpenCV-Github.png");
    // 裁剪感兴趣区域
    Rect roi;
    roi.x = 700;
    roi.y = 5;
    roi.width = 55;
    roi.height = 55;
    img = img(roi);
    imshow("roi", img);
    cv2.waitKey();
    cv2.destroyAllWindows();
    return;
    

    2.EDSR

    Lim等人在他们的论文中提出了两种方法,EDSR和MDSR。在EDSR方法中,不同的尺度需要不同的模型。相比之下,在MDSR模型中,一个单一的模型可以重建不同的尺度。然而,在本文中,我们只讨论EDSR。

    使用了一个ResNet风格的体系结构,没有批处理规范化层。他们发现,拿掉BN层,可以提高性能。这使得他们可以构建性能更好的更大的模型。为了克服在大型模型中发现的不稳定性,他们在每个残差块中使用了因子为0.1的残差缩放,方法是在最后一个卷积层之后放置常数缩放层。此外,在残差块后不使用ReLU激活层。

    该架构最初用比例因子2进行训练。然后在训练比例因子为3和4时使用这些预先训练的权重。这不仅加速了训练,而且提高了模型的性能。下图是EDSR方法和双三次插值方法的4倍超分辨率结果与原始高分辨率图像的对比。
    在这里插入图片描述
    (1)Python

    import cv2
    import matplotlib.pyplot as plt
    # 读取图片
    img = cv2.imread("AI-Courses-By-OpenCV-Github.png")
    img = img[5:60,700:755]
    sr = cv2.dnn_superres.DnnSuperResImpl_create()
    path = "EDSR_x4.pb"
    sr.readModel(path)
    sr.setModel("edsr",4)
    result = sr.upsample(img)
    # 调整图像大小
    resized = cv2.resize(img,dsize=None,fx=4,fy=4)
    plt.figure(figsize=(12,8))
    plt.subplot(1,3,1)
    # 原始图像
    plt.imshow(img[:,:,::-1])
    plt.subplot(1,3,2)
    # SR上采样图像
    plt.imshow(result[:,:,::-1])
    plt.subplot(1,3,3)
    # OpenCV 上采样图像
    plt.imshow(resized[:,:,::-1])
    plt.show()
    

    (2)C++

    #include <iostream>
    #include <opencv2/dnn_superres.hpp>
    #include <opencv2/imgproc.hpp>
    #include <opencv2/highgui.hpp>
    
    using namespace std;
    using namespace cv;
    using namespace dnn;
    using namespace dnn_superres;
    
    Mat upscaleImage(Mat img, string modelName, string modelPath, int scale){
    	DnnSuperResImpl sr;
    	sr.readModel(modelPath);
    	sr.setModel(modelName,scale);
    	// 输出图片
    	Mat outputImage;
    	sr.upsample(img, outputImage);
    	return outputImage;
    }
    
    int main(int argc, char *argv[])
    {
    	// 读取图片
    	Mat img = imread("AI-Courses-By-OpenCV-Github.png");
    	// 裁剪感兴趣区域
    	Rect roi;
    	roi.x = 700;
    	roi.y = 5;
    	roi.width = 55;
    	roi.height = 55;
    	img = img(roi);
    
    	// EDSR (x4)
    	string path = "EDSR_x4.pb";
    	string modelName = "edsr";
    	int scale = 4;
    	Mat result = upscaleImage(img, modelName, path, scale);
    
    	// 使用OpenCV上采样
    	Mat resized;
    	cv::resize(img, resized, cv::Size(), scale, scale);
    
    	imshow("Original image",img);
    	imshow("SR upscaled",result);
    	imshow("OpenCV upscaled",resized);
    	waitKey(0);
    	destroyAllWindows();
    
    	return 0;
    }
    

    在这里插入图片描述
    ( 左 ) 原 始 图 像 , ( 中 ) E D S R 4 倍 放 大 图 像 , ( 右 ) 图 像 使 用 O p e n C V 的 r e s i z e 函 数 放 大 (左)原始图像,(中) EDSR4倍放大图像,(右)图像使用OpenCV的resize函数放大 ()()EDSR4()使OpenCVresize

    3.ESPCN

    Shi等人没有使用双三次滤波器对低分辨率进行尺度放大后进行超分辨率,而是在低分辨率本身提取特征映射,并使用复杂的尺度放大滤波器得到结果。上采样层仅部署在网络的末端。这确保了模型中复杂操作发生在更低的维度上,这使得它更快,特别是与其他技术相比。

    ESPCN的基本结构受到SRCNN的启发。代替传统的卷积层,使用亚像素卷积层,其作用类似于反卷积层。最后一层利用亚像素卷积层生成高分辨率图。与此同时,他们发现Tanh激活函数比标准的ReLU激活函数效果要好得多。

    下图是ESPCN方法、双三次插值方法与原始高分辨率图像的3x超分辨率结果对比。
    在这里插入图片描述
    (1)Python

    import cv2
    import matplotlib.pyplot as plt
    # 读取图片
    img = cv2.imread("AI-Courses-By-OpenCV-Github.png")
    img = img[5:60,700:755]
    sr = cv2.dnn_superres.DnnSuperResImpl_create()
    path = "ESPCN_x3.pb"
    sr.readModel(path)
    sr.setModel("espcn",3)
    result = sr.upsample(img)
    # 调整图像大小
    resized = cv2.resize(img,dsize=None,fx=3,fy=3)
    plt.figure(figsize=(6,2))
    plt.subplot(1,3,1)
    # 原始图像
    plt.imshow(img[:,:,::-1])
    plt.subplot(1,3,2)
    # SR上采样图像
    plt.imshow(result[:,:,::-1])
    plt.subplot(1,3,3)
    # OpenCV 上采样图像
    plt.imshow(resized[:,:,::-1])
    plt.show()
    

    (2)C++

    #include <iostream>
    #include <opencv2/dnn_superres.hpp>
    #include <opencv2/imgproc.hpp>
    #include <opencv2/highgui.hpp>
    
    using namespace std;
    using namespace cv;
    using namespace dnn;
    using namespace dnn_superres;
    
    Mat upscaleImage(Mat img, string modelName, string modelPath, int scale){
    	DnnSuperResImpl sr;
    	sr.readModel(modelPath);
    	sr.setModel(modelName,scale);
    	// Output image
    	Mat outputImage;
    	sr.upsample(img, outputImage);
    	return outputImage;
    }
    
    int main(int argc, char *argv[])
    {
    	// 读取图片
    	Mat img = imread("AI-Courses-By-OpenCV-Github.png");
    	// 裁剪感兴趣区域
    	Rect roi;
    	roi.x = 700;
    	roi.y = 5;
    	roi.width = 55;
    	roi.height = 55;
    	img = img(roi);
    
    	// ESPCN (x3)
    	string path = "ESPCN_x3.pb";
    	string modelName = "espcn";
    	int scale = 3;
    	Mat result = upscaleImage(img, modelName, path, scale);
    
    	// 使用OpenCV调整图像大小
    	Mat resized;
    	cv::resize(img, resized, cv::Size(), scale, scale);
    
    	imshow("Original image",img);
    	imshow("SR upscaled",result);
    	imshow("OpenCV upscaled",resized);
    	waitKey(0);
    	destroyAllWindows();
    
    	return 0;
    }
    

    在这里插入图片描述
    ( 左 ) 原 始 图 像 , ( 中 ) E S P C N x 3 升 级 图 像 , ( 右 ) 图 像 使 用 O p e n C V 的 r e s i z e 函 数 放 大 (左)原始图像,(中)ESPCN_x3升级图像,(右)图像使用OpenCV的resize函数放大 ()()ESPCNx3()使OpenCVresize

    4.FSRCNN

    FSRCNN和ESPCN有着非常相似的概念。它们的基本结构都受到SRCNN的启发,并在最后采用了上采样层以提高速度,而不是在早期插入它。此外,他们甚至缩小了输入特征维数,使用更小的滤波器尺寸,最后使用更多的映射层,这使得模型更小更快。

    下图是FSRCNN方法、双三次插值方法与原始高分辨率图像的3x超分辨率结果对比。
    在这里插入图片描述
    (1)Python

    import cv2
    import matplotlib.pyplot as plt
    # 读取图片
    img = cv2.imread("AI-Courses-By-OpenCV-Github.png")
    img = img[5:60,700:755]
    sr = cv2.dnn_superres.DnnSuperResImpl_create()
    path = "FSRCNN_x3.pb"
    sr.readModel(path)
    sr.setModel("fsrcnn",3)
    result = sr.upsample(img)
    # 调整图像大小
    resized = cv2.resize(img,dsize=None,fx=3,fy=3)
    plt.figure(figsize=(6,2))
    plt.subplot(1,3,1)
    # 原始图像
    plt.imshow(img[:,:,::-1])
    plt.subplot(1,3,2)
    # SR上采样图像
    plt.imshow(result[:,:,::-1])
    plt.subplot(1,3,3)
    # OpenCV 上采样图像
    plt.imshow(resized[:,:,::-1])
    plt.show()
    

    (2)C++

    #include <iostream>
    #include <opencv2/dnn_superres.hpp>
    #include <opencv2/imgproc.hpp>
    #include <opencv2/highgui.hpp>
    
    using namespace std;
    using namespace cv;
    using namespace dnn;
    using namespace dnn_superres;
    
    Mat upscaleImage(Mat img, string modelName, string modelPath, int scale){
    	DnnSuperResImpl sr;
    	sr.readModel(modelPath);
    	sr.setModel(modelName,scale);
    	// 输出
    	Mat outputImage;
    	sr.upsample(img, outputImage);
    	return outputImage;
    }
    
    int main(int argc, char *argv[])
    {
    	// 读取图片
    	Mat img = imread("AI-Courses-By-OpenCV-Github.png");
    	// 裁剪ROI
    	Rect roi;
    	roi.x = 850;
    	roi.y = 0;
    	roi.width = img.size().width - 850;
    	roi.height = 80;
    	img = img(roi);
    
    	// FSRCNN (x3)
    	string path = "FSRCNN_x3.pb";
    	string modelName = "fsrcnn";
    	int scale = 3;
    	Mat result = upscaleImage(img, modelName, path, scale);
    
    	// 使用OpenCV调整图像大小
    	Mat resized;
    	cv::resize(img, resized, cv::Size(), scale, scale);
    
    	imshow("Original image",img);
    	imshow("SR upscaled",result);
    	imshow("OpenCV upscaled",resized);
    	waitKey(0);
    	destroyAllWindows();
    	return 0;
    }
    
    

    在这里插入图片描述
    ( 左 ) 原 始 图 像 , 中 ( ) F S R C N N _ 3 倍 的 放 大 图 像 , ( 右 ) 使 用 O p e n C V 的 r e s i z e 函 数 放 大 图 像 (左)原始图像,中()FSRCNN\_3倍的放大图像,(右)使用OpenCV的resize函数放大图像 ()()FSRCNN_3()使OpenCVresize

    5.LapSRN

    LapSRN在开始和结束的对比策略中提供了一个中间地带。它建议一直到最后都要温和地上采样。它的名字是基于拉普拉斯金字塔的,结构基本上就像一个金字塔,在低分辨率的图像上不断升级,直到最后。对于速度,参数共享是非常依赖的;就像EDSR模型一样,他们还提出了一个可以重建不同尺度的单一模型,称之为MS-LapSRN。然而,在本文中,我们只讨论LapSRN。

    该模型包括两个分支:特征提取和图像重建。不同尺度之间存在参数共享,例如4x使用2x模型的参数等。这意味着一个金字塔用于缩放2x,两个用于缩放4x,三个用于缩放8x!制作这种深度模型意味着它们可能会遇到梯度消失的问题。因此,他们尝试不同类型的本地跳连接,如不同源跳连接和共享源连接。模型的损失函数使用Charbonnier损失,不使用批处理归一化层。

    下图是LapSRN方法和双三次插值方法的8倍超分辨率结果与原始高分辨率图像的对比。
    在这里插入图片描述
    (1)Python

    import cv2
    import matplotlib.pyplot as plt
    # 读取图片
    img = cv2.imread("AI-Courses-By-OpenCV-Github.png")
    img = img[5:60,700:755]
    sr = cv2.dnn_superres.DnnSuperResImpl_create()
    path = "LapSRN_x8.pb"
    sr.readModel(path)
    sr.setModel("lapsrn",8)
    result = sr.upsample(img)
    # 调整图像大小
    resized = cv2.resize(img,dsize=None,fx=8,fy=8)
    plt.figure(figsize=(6,2))
    plt.subplot(1,3,1)
    # 原始图像
    plt.imshow(img[:,:,::-1])
    plt.subplot(1,3,2)
    # SR上采样图像
    plt.imshow(result[:,:,::-1])
    plt.subplot(1,3,3)
    # OpenCV 上采样图像
    plt.imshow(resized[:,:,::-1])
    plt.show()
    

    (2)C++

    #include <iostream>
    #include <opencv2/dnn_superres.hpp>
    #include <opencv2/imgproc.hpp>
    #include <opencv2/highgui.hpp>
    
    using namespace std;
    using namespace cv;
    using namespace dnn;
    using namespace dnn_superres;
    
    Mat upscaleImage(Mat img, string modelName, string modelPath, int scale){
    	DnnSuperResImpl sr;
    	sr.readModel(modelPath);
    	sr.setModel(modelName,scale);
    	// 输出
    	Mat outputImage;
    	sr.upsample(img, outputImage);
    	return outputImage;
    }
    
    int main(int argc, char *argv[])
    {
    	// 读取图片
    	Mat img = imread("AI-Courses-By-OpenCV-Github.png");
    	// 裁剪感兴趣区域
    	Rect roi;
    	roi.x = 850;
    	roi.y = 0;
    	roi.width = img.size().width - 850;
    	roi.height = 80;
    	img = img(roi);
    
    	// LapSRN (x2)
    	string path = "LapSRN_x8.pb";
    	string modelName = "lapsrn";
    	int scale = 8;
    	Mat result = upscaleImage(img, modelName, path, scale);
    
    	// 使用OpenCV的上采样
    	Mat resized;
    	cv::resize(img, resized, cv::Size(), scale, scale);
    
    	imshow("Original image",img);
    	imshow("SR upscaled",result);
    	imshow("OpenCV upscaled",resized);
    	waitKey(0);
    	destroyAllWindows();
    
    	return 0;
    }
    

    在这里插入图片描述

    6.结果对比

    在这里插入图片描述
    为了显示这里的结果,上面图像中只有蝴蝶区域被裁剪掉了。使用超分辨率模型进行了四次放大,如下表所示。
    在这里插入图片描述
    比较的Python代码:

    import cv2
    import matplotlib.pyplot as plt
    
    # 读取图片
    img = cv2.imread("image.png")
    plt.imshow(img[130:290, 150:360, ::-1])
    # plt.show()
    plt.figure(figsize=(12, 8))
    img = img[130:290, 150:360]
    
    # EDSR_x4
    sr = cv2.dnn_superres.DnnSuperResImpl_create()
    path = "EDSR_x4.pb"
    sr.readModel(path)
    sr.setModel("edsr", 4)
    result_edsr = sr.upsample(img)
    plt.subplot(2, 2, 1)
    plt.xticks([])
    plt.yticks([])
    plt.xlabel("EDSR_x4")
    plt.imshow(result_edsr[:, :, ::-1])
    
    # ESPCN_x4
    sr = cv2.dnn_superres.DnnSuperResImpl_create()
    path = "ESPCN_x4.pb"
    sr.readModel(path)
    sr.setModel("espcn", 4)
    result_espcn = sr.upsample(img)
    plt.subplot(2, 2, 2)
    plt.xticks([])
    plt.yticks([])
    plt.xlabel("ESPCN_x4")
    plt.imshow(result_espcn[:, :, ::-1])
    
    # FSRCNN_x4
    sr = cv2.dnn_superres.DnnSuperResImpl_create()
    path = "FSRCNN_x4.pb"
    sr.readModel(path)
    sr.setModel("fsrcnn", 4)
    result_fsrcnn = sr.upsample(img)
    plt.subplot(2, 2, 3)
    plt.xticks([])
    plt.yticks([])
    plt.xlabel("FSRCNN_x4")
    plt.imshow(result_fsrcnn[:, :, ::-1])
    
    # LapSRN_x4
    sr = cv2.dnn_superres.DnnSuperResImpl_create()
    path = "LapSRN_x4.pb"
    sr.readModel(path)
    sr.setModel("lapsrn", 4)
    result_lapsrn = sr.upsample(img)
    plt.subplot(2, 2, 4)
    plt.imshow(result_lapsrn[:, :, ::-1])
    plt.xticks([])
    plt.yticks([])
    plt.xlabel("LapSRN_x4")
    plt.show()
    
    

    仅仅通过放大图像,用肉眼很难分辨出不同的结果。因此,为了验证所有模型的性能,这些技术被应用于3张尺寸为500x333的图像,并缩小到所需的尺寸,然后将其上采样回500x333。然后利用PSNRSSIM将放大后的图像与原始图像进行比较。计算了所有图像的平均结果,如下图所示。
    平均PSNR值以dB为单位
    平均SSIM值
    此外,还记录了在Intel i5-7200U上花费的时间,下面给出了所有图像的平均值。请记住,3x的图像大小花费的时间小于2x,如果缩放系数更大,情况也是如此。
    平均秒数
    (1)Python

    import numpy as np
    import cv2 as cv
    import argparse
    import sys
    
    
    def getPSNR(I1, I2):
        s1 = cv.absdiff(I1, I2)  # |I1 - I2|
        s1 = np.float32(s1)  # 这里我们使用的CV_32F来计算,因为8位无符号char是不能进行平方计算
        s1 = s1 * s1  # |I1 - I2|^2
        sse = s1.sum()  # 每通道元素和
        if sse <= 1e-10:
            return 0  # 对于较小的值返回0
        else:
            shape = I1.shape
            mse = 1.0 * sse / (shape[0] * shape[1] * shape[2])
            psnr = 10.0 * np.log10((255 * 255) / mse)
            return psnr
    
    
    def getMSSISM(i1, i2):
        C1 = 6.5025
        C2 = 58.5225
        # INITS
    
        I1 = np.float32(i1)  # 不能在单字节像素上进行计算,范围不够。
        I2 = np.float32(i2)
    
        I2_2 = I2 * I2  # I2^2
        I1_2 = I1 * I1  # I1^2
        I1_I2 = I1 * I2  # I1 * I2
        # END INITS
    
        # PRELIMINARY COMPUTING
        mu1 = cv.GaussianBlur(I1, (11, 11), 1.5)
        mu2 = cv.GaussianBlur(I2, (11, 11), 1.5)
    
        mu1_2 = mu1 * mu1
        mu2_2 = mu2 * mu2
        mu1_mu2 = mu1 * mu2
    
        sigma1_2 = cv.GaussianBlur(I1_2, (11, 11), 1.5)
        sigma1_2 -= mu1_2
    
        sigma2_2 = cv.GaussianBlur(I2_2, (11, 11), 1.5)
        sigma2_2 -= mu2_2
    
        sigma12 = cv.GaussianBlur(I1_I2, (11, 11), 1.5)
        sigma12 -= mu1_mu2
    
        t1 = 2 * mu1_mu2 + C1
        t2 = 2 * sigma12 + C2
        t3 = t1 * t2  # t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
    
        t1 = mu1_2 + mu2_2 + C1
        t2 = sigma1_2 + sigma2_2 + C2
        t1 = t1 * t2  # t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
    
        ssim_map = cv.divide(t3, t1)  # ssim_map =  t3./t1;
    
        mssim = cv.mean(ssim_map)  # mssim = average of ssim map
        return mssim
    
    
    if __name__ == "__main__":
        # 读取输入的两幅图像,要保证两张图像大小一致
        img1 = cv.imread('image.jpg')
        img2 = cv.imread('output.jpg')
        img2 = cv.resize(img2, (img1.shape[1],img1.shape[0]))
        print(img1.shape)
        print(img2.shape)
        # 调用函数
        psnr = getPSNR(img1, img2)
        mssimV = getMSSISM(img1, img2)
        print(psnr)
        print(mssimV)
    
    

    (2)C++

    #include <opencv2/core/core.hpp>
    #include <opencv2/highgui/highgui.hpp> 
    // 2个图像之间PSNR值越大,则越相似。
    //输入格式是Mat类型,I1,I2代表是输入的两幅图像
    double getPSNR(const Mat& I1, const Mat& I2)
    {
        Mat s1;
        absdiff(I1, I2, s1);       // |I1 - I2|AbsDiff函数是 OpenCV 中计算两个数组差的绝对值的函数
        s1.convertTo(s1, CV_32F);  // 这里我们使用的CV_32F来计算,因为8位无符号char是不能进行平方计算
        s1 = s1.mul(s1);           // |I1 - I2|^2
        Scalar s = sum(s1);         //对每一个通道进行加和
        double sse = s.val[0] + s.val[1] + s.val[2]; // sum channels
        if( sse <= 1e-10) // 对于非常小的值我们将约等于0
            return 0;
        else
        {
            double  mse =sse /(double)(I1.channels() * I1.total());//计算MSE
            double psnr = 10.0*log10((255*255)/mse);
            return psnr;//返回PSNR
        }
    }
    Scalar getMSSIM( const Mat& i1, const Mat& i2)
    {
    	 const double C1 = 6.5025, C2 = 58.5225;
    	 /***************************** INITS **********************************/
    	 int d = CV_32F;
    	 Mat I1, I2;
    	 i1.convertTo(I1, d);           // 不能在单字节像素上进行计算,范围不够。
    	 i2.convertTo(I2, d);
    	
    	 Mat I2_2   = I2.mul(I2);        // I2^2
    	 Mat I1_2   = I1.mul(I1);        // I1^2
    	 Mat I1_I2  = I1.mul(I2);        // I1 * I2
    	
    	 /***********************初步计算 ******************************/
    	
    	 Mat mu1, mu2;   //初步的计算
    	 GaussianBlur(I1, mu1, Size(11, 11), 1.5);
    	 GaussianBlur(I2, mu2, Size(11, 11), 1.5);
    	
    	 Mat mu1_2   =   mu1.mul(mu1);
    	 Mat mu2_2   =   mu2.mul(mu2);
    	 Mat mu1_mu2 =   mu1.mul(mu2);
    
    	 Mat sigma1_2, sigma2_2, sigma12;
    	 GaussianBlur(I1_2, sigma1_2, Size(11, 11), 1.5);
    	 sigma1_2 -= mu1_2;
    	 GaussianBlur(I2_2, sigma2_2, Size(11, 11), 1.5);
    	 sigma2_2 -= mu2_2;
    	 GaussianBlur(I1_I2, sigma12, Size(11, 11), 1.5);
    	 sigma12 -= mu1_mu2;
    	 / 公式 
    	 Mat t1, t2, t3;
    	 t1 = 2 * mu1_mu2 + C1;
    	 t2 = 2 * sigma12 + C2;
    	 t3 = t1.mul(t2);          // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
    	
    	 t1 = mu1_2 + mu2_2 + C1;
    	 t2 = sigma1_2 + sigma2_2 + C2;
    	 t1 = t1.mul(t2);   // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
    	
    	 Mat ssim_map;
    	 divide(t3, t1, ssim_map);     // ssim_map =  t3./t1;
    	
    	 Scalar mssim = mean( ssim_map ); // mssim = ssim_map的平均值
    	 return mssim;
    }
    int main()
    {
    	//先定义PSNR
    	double psnr;
    	Scalar mssimV;
    	//然后读取输入的两幅图像,要保证两张图像大小一致
    	Mat img1=imread('1.jpg');
    	Mat img2=imread('2.jpg');
    	//调用函数
    	psnr = getPSNR(img1,img2);  
    	mssimV = getMSSIM(img1,img2);
    	cout << " PSNR: " << setiosflags(ios::fixed) << setprecision(3) << psnrV << "dB";
    	cout << " MSSIM: "
                    << " R " << setiosflags(ios::fixed) << setprecision(2) << mssimV.val[2] * 100 << "%"
                    << " G " << setiosflags(ios::fixed) << setprecision(2) << mssimV.val[1] * 100 << "%"
                    << " B " << setiosflags(ios::fixed) << setprecision(2) << mssimV.val[0] * 100 << "%";
    }
    

    在考察压缩后的视频时,这个值大约在30到50之间,数字越大则表明压缩质量越好。如果图像差异很明显,就可能会得到15甚至更低的值。PSNR算法简单,检查的速度也很快。但是其呈现的差异值有时候和人的主观感受不成比例。所以有另外一种称作结构相似性(Structural Similarity Index Measure, SSIM)的算法做出了这方面的改进。

    SSIM操作会针对图像的每个通道返回一个相似度,取值范围应该在0到1之间,取值为1时代表完全符合。然而尽管SSIM能产生更优秀的数据,但是由于高斯模糊很花时间,所以在一个实时系统(每秒24帧)中,人们还是更多地采用PSNR算法。

    正是这个原因,最开始的源码里,我们用PSNR算法去计算每一帧图像,而仅当PSNR算法计算出的结果低于输入值的时候,用SSIM算法去验证。

    应用

    超分辨率不仅仅是将科幻或犯罪电影的侦查变成现实的工具。超分辨率的应用遍及各个领域。

    • 医学成像(Medical Imaging):超分辨率是提高x射线和CT扫描质量的一个很好的解决方案。它有助于突出有关人体解剖和功能信息的重要细节。提高分辨率或增强医学图像也有助于突出肿瘤。
    • 多媒体,图像和视频处理应用(Multimedia, Image, and Video Processing Applications):超分辨率可以将手机视频中的模糊帧转换成清晰可读的图像或快照。
    • 生物识别(Biometric Identification):通过对人脸、指纹和虹膜图像的增强,超分辨率在生物识别中起着至关重要的作用。形状、结构和纹理都得到了极大的增强,这有助于识别生物指纹。
    • 遥感(Remote Sensing):在遥感和卫星成像中使用超分辨率的概念已经发展了几十年。事实上,第一个超分辨率的想法是由对更高质量和更高分辨率的陆地卫星遥感图像的需求所激发的。
    • 天文成像(Astronomical imaging):提高天文图片的分辨率有助于关注微小的细节,这些微小的细节可能会成为外太空的重大发现。
    • 监控成像(Surveillance Imaging):交通监控和安全系统在维护平民安全方面起着非常重要的作用。在数字录像上应用超分辨率在识别交通或安全违规方面大有帮助。

    总结

    在这篇博客中,我们简单介绍了超分辨率的概念。我们选择了四种超分辨率模型,讨论了它们的体系结构和结果,以突出图像超分辨率选择的多样性和这些方法的效率。

    总结我们的观察,EDSR轻松地给出了四种方法中最好的结果。但是,它速度很慢,不能用于实时应用程序。ESPCN和FSRCNN是实时性和性能的首选方法。对于8倍的放大系数,即使可以使用2倍和4倍的组合模型,LapSRN的8倍放大模型在大多数情况下表现更好。虽然这些方法在速度上都不能与传统的双三次方法相媲美,但它们都具有一定的优越性。

    参考目录

    https://blog.csdn.net/yat_chiu/article/details/77893485
    https://learnopencv.com/super-resolution-in-opencv/
    http://www.opencv.org.cn/opencvdoc/2.3.2/html/doc/tutorials/highgui/video-input-psnr-ssim/video-input-psnr-ssim.html

    展开全文
  • OpenCV对摄像头分辨率的设置

    千次阅读 2013-04-14 16:34:36
    最近用双目视觉采集图像时得到的是640*480的图片,而我想要的是320*240的通过在网上查阅发现cvSetCaptureProperty函数可以达到我想要的效果: cvSetCaptureProperty(pCapture[0], CV_CAP_PROP_FRAME_WIDTH, 320); ...
  • Visual Studio 2019 搭配OpenCV图片显示大小进行调整: resize函数使用实例 大家好,在使用Visual Studio 2019 搭配OpenCV图片进行处理的过程中,我们发现打开的图片会以原始状态显示,导致图片延伸到屏幕...
  • Opencv 基于MFC 显示图片 更改图片分辨率 保存图片本片文章将简单介绍,利用Opencv在MFC框架下,实现①显示图片图像 ,②更改图片图像分辨率,③保存图片的入门操作实例本文章功能实现依托于MFC的控件进行显示,所以...
  • @File : 200113_等比例调整图像分辨率大小.py @Time : 2020/1/13 13:38 @Author : Dontla @Email : sxana@qq.com @Software: PyCharm """ import cv2 def img_resize(image): heigh...
  • OpenCV中的超分辨率

    2021-03-28 00:40:41
    请关注此博客,以了解OpenCV中“超分辨率”的选项。当增加图像的尺寸时,需要以某种方式插入额外的像素。基本的图像处理技术无法提供良好的效果,因为它们在放大时不会考​​虑周围环境。深度学习以及最近的GAN在...
  • Opencv调整运行窗口图片的大小

    千次阅读 2019-01-03 16:09:43
    Opencv在运算时显示图片问题 总结在opencv中,图片显示的问题。简要解决图片窗口和图片大小的问题。 namedWindow("窗口名",1);//创建窗口 imshow("窗口名",要显示的图片);//在创建的窗口中显示...
  • opencv重新调整图片大小

    千次阅读 2018-07-29 13:11:26
    //2.IplImage调整大小 IplImage* MyResizeImage(IplImage* pSrc, double dScale) { CvSize size; size.width = pSrc->width*dScale; size.height = pSrc->height*dScale; IplImage *pDes = cvCreateImage...
  • android opencv修改 camera 输出分辨率

    千次阅读 2014-01-06 15:18:48
    首先介绍opencv提供的两个class:CameraBridgeViewBase,JavaCameraView  1. CameraBridgeViewBase 中有方法  1) onEnterStartedState  该方法中调用了connectCamera接口,可以给camera设置分辨率。  源码中...
  • opencv调整图片大小并保存

    千次阅读 2015-10-27 22:37:53
    cvSaveImage()这个第一个参数,我用的是绝对路径才能正确的保存修改后的图片#include #include #include #include #include using namespace std; #pragma comment(lib, "opencv_core242d.lib") #pragma ...
  • 针对不同分辨率的匹配操作项目要求OpenCV模板匹配模板匹配的工作方式模板匹配的匹配方式模板匹配存在的问题解决方法方法1:直方图+自适应模板匹配结果方法二:SIFT效果方法三:灰度匹配+模板匹配 项目要求 有一个...
  • 使用python+opencv批量修改视频分辨率

    千次阅读 2019-09-21 10:12:57
    当录取很多视频文件后,发现视频的分辨率不符合要求,于是使用python把320240的视频转换成160120的视频。...思路是:先对视频逐帧改分辨率,再将每一帧的图片合成视频,加上声音。 代码如下: 在这里插入代码片 ...
  • OpenCV生成的图像相对较大,可能类似对应Photoshop最佳的那种保存的,但是我想要相对小一些的图像,请问如何才能用OpenCV设置JPG图像的压缩质量? 通常用opencv中的函数cvSaveImage(filename,img)来保存图像,很...
  • 6.opencv调整图像大小的新方法imutils.resize一、openCV 调整图像大小 ( cv2.resize )二、项目结构和代码讲解1.项目结构2.代码讲解3.比较 OpenCV 插值方法4.OpenCV 图像大小调整结果三、代码下载 在本教程中,您将...
  • 直到读了这篇博文才发现问题所在,现在可以读取的分辨率可以达到1280*960。 原文地址为:https://blog.csdn.net/kyjl888/article/details/69367912 1 问题最初起因 我想充分利用相机高分辨率来提高视角,故用...
  • python opencv-批量调整图片的曝光率

    万次阅读 2018-01-28 20:59:25
    因此,虽然这种方法对图片的曝光率具有较好的调整效果,但是如果素材明暗差异较大,在调整调整较亮或较暗区域时,要注意减小对较暗或较亮区域的影响。事实上可以根据相同的原理,利用插值的方法构造相对应的处理函数...
  • opencv imshow显示图片

    千次阅读 2018-06-21 17:23:23
    opencv中用imshow显示图片会出现图片被放大的现象,首先图片是手机拍摄的有3兆多,分辨率3000x4000.显示的时候图片被放大得超级大,只显示出了一小部分。在转换成几十kb之后,能显示出个整体了,但还是有一点放大...
  • 相信很多人都会遇到:报名考试的时候上传图片,或者实名认证的时候上传身份证正反面照片的时候,都会遇到分辨率(156*143?)、图片大小(500kb?)的限制。那么在现在手机像素都很高,都会去找一些软件啊或者其他的...
  • 近日在用opencv做一些图像处理的操作时,需要对一些高分辨率的图像进行保存。比如,在操作一个容量为230M的图像后,并对该图像保存为JPG格式后,发现图像容量变为80M了!针对这个问题,忙了大半天,到处翻阅资料,...

空空如也

空空如也

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

opencv调整图片分辨率