『opencv』笔记2：基于OpenCV的显著性绘制

最新推荐文章于 2024-01-24 09:17:32 发布
最新推荐文章于 2024-01-24 09:17:32 发布
阅读量1.6k 收藏 13
点赞数 5
分类专栏： opencv 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/libo1004/article/details/118060249
版权

文章目录


『opencv』笔记1：基于 OpenCV 的图像融合

1 OpenCV显著性算法背景介绍

1.1 OpenCV显著性检测算法相关信息介绍

OpenCV contrib 库中的 saliency 模块提供四种显著性检测算法。本节主要介绍这四种方法的相关信息。

1.1.1 Static Saliency Spectral Residual

  • 原理：该方法从自然图像统计原理出发，模拟注意前视觉搜索的行为。该算法对每幅图像的对数谱进行分析，得到谱残差SR (Spectral Residual)。然后将谱残差进行空间变换，得到显著性图，该显著性图显示了感兴趣目标的位置。
  • 论文：Saliency Detection: A Spectral Residual Approach
  • 检测方式：单张图片检测

实现方式

// c++ demo
saliencyAlgorithm = StaticSaliencySpectralResidual::create();
bool success = saliencyAlgorithm -> computeSaliency(image, saliencyMap);		// 计算显著性

# python demo
saliencyAlgorithm = cv2.saliency.StaticSaliencySpectralResidual_create()
success, saliencyMap = saliencyAlgorithm.computeSaliency(image)		# 计算显著性

1.1.2 Static Saliency Fine Grained

实现方式

// c++ demo
saliencyAlgorithm = StaticSaliencyFineGrained::create();
bool success = saliencyAlgorithm->computeSaliency(image, saliencyMap);		// 计算显著性

# python demo
saliencyAlgorithm = cv2.saliency.StaticSaliencyFineGrained_create()
success, saliencyMap = saliencyAlgorithm.computeSaliency(image)		# 计算显著性

1.1.3 Objectness BING

实现方式

// c++ demo
saliencyAlgorithm = ObjectnessBING::create();
vector<Vec4i> saliencyMap;
saliencyAlgorithm.dynamicCast<ObjectnessBING>()->setTrainingPath(training_path);	// 提取模型文件参数
saliencyAlgorithm.dynamicCast<ObjectnessBING>()->setBBResDir("Results");	// 将算法检测结果保存在Results文件夹内
bool success = saliencyAlgorithm->computeSaliency(image, saliencyMap);	// 计算显著性

# python demo
saliencyAlgorithm = cv2.saliency.ObjectnessBING_create()
saliencyAlgorithm.setTrainingPath(training_path)	# 提取模型文件参数
saliencyAlgorithm.setBBResDir("Results")	# 将算法检测结果保存在Results文件夹内
success, saliencyMap = saliencyAlgorithm.computeSaliency(image)	# 计算显著性

1.1.4 BinWangApr2014

实现方式

// c++ demo
saliencyAlgorithm = MotionSaliencyBinWangApr2014::create();
saliencyAlgorithm.dynamicCast<MotionSaliencyBinWangApr2014>()->setImagesize(image.cols, image.rows);	// 设置数据结构大小
saliencyAlgorithm.dynamicCast<MotionSaliencyBinWangApr2014>()->init();	// 初始化
saliencyAlgorithm->computeSaliency(frame, saliencyMap);

# python demo
saliencyAlgorithm = cv2.saliency.MotionSaliencyBinWangApr2014_create()
saliencyAlgorithm.setImagesize(image.shape[1], image.shape[0])	# 设置数据结构大小
saliencyAlgorithm.init()	# 初始化
success, saliencyMap = saliencyAlgorithm.computeSaliency(frame)

1.2 OpenCV saliency 模块整体说明

显著性检测算法与目标检测算法大大不同。显著性检测算法，只是判断图中有显著目标的区域，这些区域可能包含目标也可能不包含目标，因方法而异。类比人眼的观察方式，显著性检测算法是许多计算机视觉任务的第一步，检测出显著性区域后，对这些显著性区域进行进一步判断和预测。显著性检测算法通常检测速度较快，某些计算量大的算法如深度学习图像分类算法，可以只在显著性区域上运行，以缩小检测范围，加快检测速度，提高检测精度。

OpenCV saliency模块提供了四种不同的显著性检测方法，但是按方法类别只有三种。OpenCV saliency模块的类关系如下图所示：
在这里插入图片描述
OpenCV saliency模块提供的三种不同方法类别模块介绍如下：

  • Motion saliency模块：这类算法输入为连续的图像帧，通过运动检测算法对连续图像帧进行处理，然后对运动目标进行跟踪，最终将运动目标设置为显著区域。代表为 BinWangApr2014 算法。该类算法容易出现丢帧和鬼影情况，运动检测效果不如主流的运动检测算法，实际图像显著性检测效果一般。
  • Objectness模块：这类算法输入为单帧图像，通过计算得到大量的建议区域，并将这些建议区域作为显著性区域。代表为 ObjectnessBING 算法。该类算法检测速度较慢，实际检测出来的建议区域可能上万个，需要进行筛选，总体效果一般。
  • Static saliency模块：这类算法输入为单帧图像，通过图像特征和统计量来定位图像中的显著性区域。代表为Static Saliency Spectral Residual 和 Static Saliency Fine Grained。该类算法检测速度非常快，不过效果总体一般。

2 代码实现

本文所提供的代码可以对视频或者图像进行显著性检测，BinWangApr2014 只能对视频进行显著性检测。本文提供 C++ 和 Python 代码实现，代码如下：

C++

#include <opencv2/opencv.hpp>
#include <opencv2/saliency.hpp>
#include <iostream>

using namespace std;
using namespace cv;
using namespace saliency;

int main()
{
	// 显著性检测算法
	// 可选：SPECTRAL_RESIDUAL，FINE_GRAINED，BING，BinWangApr2014
	String saliency_algorithm = "FINE_GRAINED";
	String video_name = "video/vtest.avi";	// 检测视频或者图像
	// String video_name = "video/dog.jpg";
	int start_frame = 0;	// 起始帧
	String training_path = "ObjectnessTrainedModel";	// 模型路径
	// 如果算法名和视频名为空，停止检测
	if (saliency_algorithm.empty() || video_name.empty())
	{
		cout << "Please set saliency_algorithm and video_name";
		return -1;
	}

	VideoCapture cap;
	cap.open(video_name);
	cap.set(CAP_PROP_POS_FRAMES, start_frame);	// 设置视频起始帧

	Mat frame;	// 输入图像

	// 实例化 saliencyAlgorithm 结构
	Ptr<Saliency> saliencyAlgorithm;

	Mat binaryMap;	// 二值化检测结果
	Mat image;	// 检测图像

	cap >> frame;	// 读图
	if (frame.empty())
	{
		return 0;
	}

	frame.copyTo(image);

	// 根据输入的方法确定检测类型
	// StaticSaliencySpectralResidual
	if (saliency_algorithm.find("SPECTRAL_RESIDUAL") == 0)
	{
		Mat saliencyMap;	// 检测结果，白色区域表示显著区域
		saliencyAlgorithm = StaticSaliencySpectralResidual::create();
		double start = static_cast<double>(getTickCount());	// 计算显著性
		bool success = saliencyAlgorithm->computeSaliency(image, saliencyMap);
		double duration = ((double)getTickCount() - start) / getTickFrequency();
		cout << "computeSaliency cost time is: " << duration * 1000 << "ms" << endl;

		if (success)
		{
			StaticSaliencySpectralResidual spec;
			double start = static_cast<double>(getTickCount());	// 二值化图像
			spec.computeBinaryMap(saliencyMap, binaryMap);
			double duration = ((double)getTickCount() - start) / getTickFrequency();
			cout << "computeBinaryMap cost time is: " << duration * 1000 << "ms" << endl;

			imshow("Original Image", image);
			imshow("Saliency Map", saliencyMap);
			imshow("Binary Map", binaryMap);

			saliencyMap.convertTo(saliencyMap, CV_8UC3, 256);	// 转换格式才能保存图片
			imwrite("Results/SPECTRAL_RESIDUAL_saliencyMap.jpg", saliencyMap);
			imwrite("Results/SPECTRAL_RESIDUAL_binaryMap.jpg", binaryMap);
			waitKey(0);
		}
	}

	// StaticSaliencyFineGrained
	else if (saliency_algorithm.find("FINE_GRAINED") == 0)
	{
		Mat saliencyMap;
		saliencyAlgorithm = StaticSaliencyFineGrained::create();
		double start = static_cast<double>(getTickCount());	// 计算显著性
		bool success = saliencyAlgorithm->computeSaliency(image, saliencyMap);
		double duration = ((double)getTickCount() - start) / getTickFrequency();
		cout << "computeSaliency cost time is: " << duration * 1000 << "ms" << endl;

		if (success)
		{
			StaticSaliencyFineGrained spec;
			double start = static_cast<double>(getTickCount());	// 二值化图像
			spec.computeBinaryMap(saliencyMap, binaryMap);
			double duration = ((double)getTickCount() - start) / getTickFrequency();
			cout << "computeBinaryMap cost time is: " << duration * 1000 << "ms" << endl;

			imshow("Saliency Map", saliencyMap);
			imshow("Original Image", image);
			imshow("Binary Map", binaryMap);

			saliencyMap.convertTo(saliencyMap, CV_8UC3, 256);	// 转换格式才能保存图片
			imwrite("Results/FINE_GRAINED_saliencyMap.jpg", saliencyMap);
			imwrite("Results/FINE_GRAINED_binaryMap.jpg", binaryMap);
			waitKey(0);
		}
	}

	// ObjectnessBING
	else if (saliency_algorithm.find("BING") == 0)
	{
		// 判断模型是否存在
		if (training_path.empty())
		{
			cout << "Path of trained files missing! " << endl;
			return -1;
		}

		else
		{
			saliencyAlgorithm = ObjectnessBING::create();
			vector<Vec4i> saliencyMap;
			
			saliencyAlgorithm.dynamicCast<ObjectnessBING>()->setTrainingPath(training_path);	// 提取模型文件参数
			saliencyAlgorithm.dynamicCast<ObjectnessBING>()->setBBResDir("Results");	// 将算法检测结果保存在Results文件夹内

			double start = static_cast<double>(getTickCount());	// 计算显著性
			bool success = saliencyAlgorithm->computeSaliency(image, saliencyMap);
			double duration = ((double)getTickCount() - start) / getTickFrequency();
			cout << "computeSaliency cost time is: " << duration * 1000 << "ms" << endl;

			if (success)
			{
				int ndet = int(saliencyMap.size());	// saliencyMap获取检测到的目标个数
				std::cout << "Objectness done " << ndet << std::endl;
				// 目标按可能性从大到小排列，maxd为显示前5个目标，step设置颜色，jitter设置矩形框微调
				int maxd = 5, step = 255 / maxd, jitter = 9;
				Mat draw = image.clone();
				for (int i = 0; i < std::min(maxd, ndet); i++)
				{
					Vec4i bb = saliencyMap[i];	// 获得矩形框坐标点
					Scalar col = Scalar(((i*step) % 255), 50, 255 - ((i*step) % 255));	// 设定颜色
					Point off(theRNG().uniform(-jitter, jitter), theRNG().uniform(-jitter, jitter));	// 矩形框微调
					rectangle(draw, Point(bb[0] + off.x, bb[1] + off.y), Point(bb[2] + off.x, bb[3] + off.y), col, 2);	// 画矩形
					rectangle(draw, Rect(20, 20 + i * 10, 10, 10), col, -1);	// 颜色标注
				}
				imshow("BING", draw);

				imwrite("Results/BING_draw.jpg", draw);
				waitKey();
			}
			else
			{
				std::cout << "No saliency found for " << video_name << std::endl;
			}
		}
	}

	// BinWangApr2014
	else if (saliency_algorithm.find("BinWangApr2014") == 0)
	{
		saliencyAlgorithm = MotionSaliencyBinWangApr2014::create();
		saliencyAlgorithm.dynamicCast<MotionSaliencyBinWangApr2014>()->setImagesize(image.cols, image.rows);	// 设置数据结构大小
		saliencyAlgorithm.dynamicCast<MotionSaliencyBinWangApr2014>()->init();	// 初始化

		bool paused = false;
		for (;; )
		{
			if (!paused)
			{
				cap >> frame;
				if (frame.empty())
				{
					return 0;
				}
				cvtColor(frame, frame, COLOR_BGR2GRAY);

				Mat saliencyMap;
				double start = static_cast<double>(getTickCount());
				saliencyAlgorithm->computeSaliency(frame, saliencyMap);
				double duration = ((double)getTickCount() - start) / getTickFrequency();
				cout << "computeSaliency cost time is: " << duration * 1000 << "ms" << endl;

				imshow("image", frame);
				imshow("saliencyMap", saliencyMap * 255);
			}

			char c = (char)waitKey(2);
			if (c == 'q')
				break;
			if (c == 'p')
				paused = !paused;
		}
	}
	destroyAllWindows();
	return 0;
}

python

# -*- coding: utf-8 -*-
import cv2
import random

def main():
    # 显著性检测算法
    # 可选：SPECTRAL_RESIDUAL，FINE_GRAINED，BING，BinWangApr2014
    saliency_algorithm = "FINE_GRAINED"
    video_name = "video/vtest.avi"
    # video_name = "video/dog.jpg";
    start_frame = 0		# 起始帧
    training_path = "ObjectnessTrainedModel"	# 模型路径

    # 如果算法名和视频名为空，停止检测
    if saliency_algorithm is None or video_name is None:
        print("Please set saliency_algorithm and video_name")
        return
        
    cap = cv2.VideoCapture(video_name)
    cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame)	# 设置视频起始帧

    _, frame = cap.read()
    if frame is None:
        print("Please set saliency_algorithm and video_name")
        return

    image = frame.copy()

    # 根据输入的方法确定检测类型
    if saliency_algorithm.find("SPECTRAL_RESIDUAL") == 0:
        # 检测结果，白色区域表示显著区域
        saliencyAlgorithm = cv2.saliency.StaticSaliencySpectralResidual_create()
        start = cv2.getTickCount()	# 计算显著性
        success, saliencyMap = saliencyAlgorithm.computeSaliency(image)
        duration = (cv2.getTickCount() - start) / cv2.getTickFrequency()
        print("computeBinaryMap cost time is: {} ms".format(duration * 1000))

        if success:
            start = cv2.getTickCount()	# 二值化图像
            _, binaryMap = saliencyAlgorithm.computeBinaryMap(saliencyMap)
            duration = (cv2.getTickCount() - start) / cv2.getTickFrequency()
            print("computeBinaryMap cost time is: {} ms".format(duration * 1000))

            cv2.imshow("Saliency Map", saliencyMap)
            cv2.imshow("Original Image", image)
            cv2.imshow("Binary Map", binaryMap)

            saliencyMap = (saliencyMap * 255)	# 转换格式才能保存图片
            cv2.imwrite("Results/FINE_GRAINED_saliencyMap.jpg", saliencyMap)
            cv2.imwrite("Results/FINE_GRAINED_binaryMap.jpg", binaryMap)
            cv2.waitKey(0)

    # FINE_GRAINED
    elif saliency_algorithm.find("FINE_GRAINED") == 0:
        saliencyAlgorithm = cv2.saliency.StaticSaliencyFineGrained_create()
        start = cv2.getTickCount()
        success, saliencyMap = saliencyAlgorithm.computeSaliency(image)
        duration = (cv2.getTickCount() - start) / cv2.getTickFrequency()
        print("computeBinaryMap cost time is: {} ms".format(duration * 1000))
        if success:
            start = cv2.getTickCount()
            _, binaryMap = saliencyAlgorithm.computeBinaryMap(saliencyMap)
            duration = (cv2.getTickCount() - start) / cv2.getTickFrequency()
            print("computeBinaryMap cost time is: {} ms".format(duration * 1000))

            cv2.imshow("Saliency Map", saliencyMap)
            cv2.imshow("Original Image", image)
            cv2.imshow("Binary Map", binaryMap)

            saliencyMap = (saliencyMap * 255)
            cv2.imwrite("Results/FINE_GRAINED_saliencyMap.jpg", saliencyMap)
            cv2.imwrite("Results/FINE_GRAINED_binaryMap.jpg", binaryMap)
            cv2.waitKey(0)

    elif saliency_algorithm.find("BING") == 0:
        # 判断模型是否存在
        if training_path is None:
            print("Path of trained files missing! ")
            return
        else:
            saliencyAlgorithm = cv2.saliency.ObjectnessBING_create()
            saliencyAlgorithm.setTrainingPath(training_path)	# 提取模型文件参数
            saliencyAlgorithm.setBBResDir("Results")	# 将算法检测结果保存在Results文件夹内
            
            start = cv2.getTickCount()
            success, saliencyMap = saliencyAlgorithm.computeSaliency(image)
            duration = (cv2.getTickCount() - start) / cv2.getTickFrequency()
            print("computeBinaryMap cost time is: {} ms".format(duration * 1000))
            if success:
                ndet = saliencyMap.shape[0]	 # saliencyMap 获取检测到的目标个数
                print("Objectness done ", ndet)
                
                # 目标按可能性从大到小排列，maxd为显示前5个目标，step设置颜色，jitter设置矩形框微调
                maxd = 5
                step = 255 / maxd
                jitter = 9
                draw = image.copy()

                for i in range(0, min(maxd, ndet)):
                    bb = saliencyMap[i][0]
                    col = ((i * step) % 255), 50, 255 - ((i * step) % 255)
                    off = random.randint(-jitter, jitter), random.randint(-jitter, jitter)
                    cv2.rectangle(draw, (bb[0] + off[0], bb[1] + off[1]), (bb[2] + off[0], bb[3] + off[1]), col, 2)
                    cv2.rectangle(draw, (20, 20 + i * 10, 10, 10), col, -1)

                cv2.imwrite("Results/BING_draw.jpg", draw)
                cv2.imshow("BING", draw)
                cv2.waitKey(0)

    # 需要传入图像建模
    elif saliency_algorithm.find("BinWangApr2014") == 0:
        saliencyAlgorithm = cv2.saliency.MotionSaliencyBinWangApr2014_create()
        saliencyAlgorithm.setImagesize(image.shape[1], image.shape[0])	# 设置数据结构大小
        saliencyAlgorithm.init()	#  初始化
        paused = False

        while True:
            if not paused:
                _, frame = cap.read()
                if frame is None:
                    break

                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
                start = cv2.getTickCount()
                success, saliencyMap = saliencyAlgorithm.computeSaliency(frame)
                duration = (cv2.getTickCount() - start) / cv2.getTickFrequency()
                print("computeBinaryMap cost time is: {} ms".format(duration * 1000))
                cv2.imshow("image", frame)
                cv2.imshow("saliencyMap", saliencyMap * 255)

            c = cv2.waitKey(2)
            c = chr(c) if c != -1 else 0
            if c == 'q':
                break
            if c == 'p':
                paused = not paused

    cv2.destroyAllWindows()
    return

if __name__ == '__main__':
    main()

参考链接

  1. https://blog.csdn.net/LuohenYJ/article/details/108607926
libo-coder
关注
  • 5
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
基于OpenCV的显著图绘制
小白学视觉
10-23 1265
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达显着性是图像的突出部分，我们的大脑会特别关注这个部分。上图突出了我们在看到一个场景或图像时会注意到的...
opencv_02显著性图像
weixin_44248637的博客
04-27 181
使用opencv生成显著性图像
FT显著性Opencv实现
12-03
基因opencv及VS2010，实现了Frequency-tuned Salient Region Detection中的显著性方法，与原代码相比，兼容了opencv的数据格式，且运算速度提高了一倍
teechart绘制实时曲线_基于OpenCV的显著图绘制
weixin_39605578的博客
11-27 128
显着性是图像的突出部分，我们的大脑会特别关注这个部分。上图突出了我们在看到一个场景或图像时会注意到的部分。例如，大家有没有曾经在看广告的时候被一些特别的内容吸引，为此我们还特意停下来多看了一会儿？这就是广告的显着性，即使让我们可以一眼看到广告，也会被他吸引。01.安装OpenCV首先，您需要安装OpenCV库。如果已经安装了pip，则可以通过运行以下命令来完成。> pipinstall op...
图像显著性计算的FT模型Opencv
11-21
图像显著性FT模型的代码，希望对你有帮助
VS+opencv 显著性检测
12-18
显著性检测 超像素分割
OpenCV笔记
最新发布
letwant的博客
01-24 1419
Sobel算子是一种用于边缘检测的算法，在图像处理和计算机视觉中应用广泛。它主要用于计算图像灰度的一阶导数，从而突出显示图像中的边缘。者相加，构成两个方向的边缘信息。方式2：将参数dx和dy的值设为“dx=1, dy=1”，获取图像在两个方向的梯度。import cv2# 方式1，水平和垂直梯度叠加# 方式2，两个方向的梯度[外链图片转存中…(img-SSAQM2ah-1706058995401)]显然方式1效果好很多。
『opencv』笔记3：基于OpenCV的镜像与翻转
libo-coder
06-20 466
文章目录 『opencv』笔记1：基于 OpenCV 的图像融合 『opencv』笔记2：基于OpenCV的显著性绘制 镜像图像： 从左到右逐行反转矩阵 翻转图像： 从上到下逐列反转矩阵 # coding=utf-8 """ 功能：基于OpenCV的图像翻转和镜像 @author: libo """ import cv2 import numpy as np from matplotlib import pyplot as plt def read_img(image_path, gray_scal
opencv学习笔记之绘制图像直方图
weixin_45775703的博客
02-18 3209
文章目录前言一、图像直方图统计灰度值数目的calcHist（）函数原型： 前言 记录学习opencv中有关图像直方图绘制的方法 一、图像直方图 图像直方图是对图像的像素进行统计，不受到图像的旋转和平移等效果。 图像直方图具有平移不变性、放缩不变性等优点，可以用来查看图像整体的变化形式，比如图像是否过暗、图像像素灰度值主要集中在哪些范围。同时在对数字的识别当中，图像直方图也会发挥显著的作用。 图像直方图的横轴为图像的灰度值作为横轴，以灰度值的个数和比例作为纵轴去绘制统计图。 灰度值的分布一般反应了图像的亮
显著性检测
12-19
基于OpenCV的显著性检测，Linux平台，效果非常的好，亲测可用
Saliency Map opencv C++
11-17
图像显著性检测，用Saliency算法获得能量图，显示图片的显著性区域 同时显示HSL通道的显著图
opencv优质资源：OpenCV算法精解：基于Python与C
12-06
OpenCV算法精解：基于Python与C(优秀教材，值得一看)，需要请自行下载
OpenCV算法精解：基于Python与C.zip
12-05
计算机视觉，OpenCV算法精讲
OPENCV学习笔记一：图像基本操作
01-20
标题学习opencv第一天： 一、图像基本操作： 1.图像读取：cv.imread(“文件位置：D:/python/...参数2：选择读取图片的方式 IMREAD_COLOR 读取RGB3通道图片（默认） IMREAD_GRAYSCALE 读取单通道（灰度）图片 其他暂
OpenCV学习笔记：运动物体检测、跟踪和绘制曲线运动轨迹
热门推荐
fly108108的博客
04-15 3万+
一、简介         本文章的起源是本人在做一个项目，用摄像头识别笔，根据笔的运动，绘制出其轨迹。主要应用到的方法，有运动物体识别、运动物体检测，以及绘制运动物体的运动轨迹。1、 运动物体的识别方法很多，主要就是要提取相关物体的特征，主要分为：        （1）各种色彩空间直方图，利用色彩空间的直方图分布作为目标跟踪的特征的一个显著性特点是可以减少物体远近距离对跟踪的影响，因为其颜色分布大...
opencv学习笔记(26):轮廓周围绘制矩形框和圆形框
weixin_45141685的博客
03-08 169
void cv::approxPolyDP ( InputArray curve, OutputArray approxCurve, double epsilon, bool closed ) 基于RDP算法实现,目的是减少多边形轮廓点数 参数 curve Input vector of a 2D point stored in std::vector or Mat approxCurve Result of the approximation. The type should match
opencv-projects:OpenCV基于项目的学习
04-13
基于OpenCV项目的学习Rustam_Z :rocket: | 2021年1月10日图像介绍阅读图像视频和网络摄像头基本功能调整大小和裁剪形状和文字翘曲预期联接图像颜色检测轮廓/形状检测人脸检测专案虚拟绘画纸张扫描仪车牌检测讲解 ...
opencv打卡76: 显著图(Saliency Map)
huxw_magus的博客
07-02 1743
1、介绍 2、代码 3、结果
c++opencv绘制显著性图像
04-27
您好，关于您的问题，您可以按照以下步骤使用 OpenCV 绘制显著性图像： 1.读取图像并计算其显著性值 2.使用颜色映射将显著性值转换为颜色图像 3.将显著性图像与原始图像叠加以可视化 以下是样例代码： ``` import cv2 import numpy as np # Load the input image img = cv2.imread('input_image.jpg') # Convert the input image to grayscale gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # Calculate the saliency map using the spectral residual approach saliency = cv2.saliency.StaticSaliencySpectralResidual_create() (success, saliencyMap) = saliency.computeSaliency(gray) # Normalize the saliency map saliencyMap = (saliencyMap * 255).astype("uint8") # Apply a color map to the saliency map colorMap = cv2.applyColorMap(saliencyMap, cv2.COLORMAP_JET) # Blend the saliency map and the input image together alpha = 0.5 beta = 1.0 - alpha output = cv2.addWeighted(colorMap, alpha, img, beta, 0.0) # Show the output image cv2.imshow("Output", output) cv2.waitKey(0) cv2.destroyAllWindows() ``` 请注意，此代码使用了 spectral residual 算法计算显著性图像，您也可以使用其他算法计算显著性图像，具体选用哪种算法需要根据您的应用需求以及计算效率考虑。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

libo-coder

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值