图像处理100问（Question_11_20）

最新推荐文章于 2024-09-06 09:20:10 发布
最新推荐文章于 2024-09-06 09:20:10 发布
阅读量235 收藏
点赞数
分类专栏： 图像处理 文章标签： 图像处理 滤波器 边缘检测 C++ OpenCV
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mrhjlong/article/details/120328691
版权

感谢分享！
English is here (KuKuXia translates into English)
https://github.com/KuKuXia/Image_Processing_100_Questions
Chinese is here (gzr2017, my ex-colleague, translates into Chinese)
https://github.com/gzr2017/ImageProcessing100Wen
My git：
https://github.com/jamery-huang/ImageProcessing100Wen.git

基于c++版本

原code错误：

  • Question_11_20/answers_cpp/answer_11.cpp
    缺少越界保护，以及像素边缘计算均值的分母有问题，详见下文均值滤波器章节代码。

文章目录

一、均值滤波器
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
#include <math.h>

// mean filter
cv::Mat mean_filter(cv::Mat img, int kernel_size){
  int height = img.rows;
  int width = img.cols;
  int channel = img.channels();

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC3);

  // prepare kernel
  int pad = floor(kernel_size / 2);
  
  // filtering
  double v = 0;
  int vs[kernel_size * kernel_size];
  int count = 0;
  
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      for (int c = 0; c < channel; c++){
		  v = 0;
		  count = 0;
		  
		  // get pixel sum
		  for (int dy = -pad; dy < pad + 1; dy++){
			for (int dx = -pad; dx < pad + 1; dx++){
			  if (((y + dy) >= 0) && ((x + dx) >= 0)
					&& ((y + dy) < height) && ((x + dx) < width)){
				v += (int)img.at<cv::Vec3b>(y + dy, x + dx)[c];
				count++;
			  }
			}
		  }

		  // assign mean value
		  if (count > 0) {
			  v /= count;
			  out.at<cv::Vec3b>(y, x)[c] = (uchar)v;
		  }
      }
    }
  }
  return out;
}

int main(int argc, const char* argv[]){
  // read image
  cv::Mat img = cv::imread("imori.jpg", cv::IMREAD_COLOR);

  // mean filter
  cv::Mat out = mean_filter(img, 3);
  
  cv::imwrite("out1.jpg", out);
  cv::imshow("img", img);
  cv::imshow("answer", out);
  cv::waitKey(0);
  cv::destroyAllWindows();

  return 0;
}

11

二、Motion Filter
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
#include <math.h>

// motion filter
cv::Mat motion_filter(cv::Mat img, int kernel_size){
  int height = img.rows;
  int width = img.cols;
  int channel = img.channels();

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC3);

  // prepare kernel
  int pad = floor(kernel_size / 2);
  
  double kernel[kernel_size][kernel_size];//{{1./3, 0, 0}, {0, 1./3, 0}, {0, 0, 1./3}};
  
  for(int y = 0; y < kernel_size; y++){
    for(int x = 0; x < kernel_size; x++){
      if (y == x){
        kernel[y][x] = 1. / kernel_size;
      } else {
        kernel[y][x] = 0;
      }
    }
  }

  // filtering
  double v = 0;
  
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      for (int c = 0; c < channel; c++){

      v = 0;

      for (int dy = -pad; dy < pad + 1; dy++){
        for (int dx = -pad; dx < pad + 1; dx++){
          if (((y + dy) >= 0) && (( x + dx) >= 0) && ((y + dy) < height) && ((x + dx) < width)){
            v += (double)img.at<cv::Vec3b>(y + dy, x + dx)[c] * kernel[dy + pad][dx + pad];
          }
        }
      }
      out.at<cv::Vec3b>(y, x)[c] = (uchar)v;
      }
    }
  }
  return out;
}

int main(int argc, const char* argv[]){
  // read image
  cv::Mat img = cv::imread("imori.jpg", cv::IMREAD_COLOR);

  // motion filter
  cv::Mat out = motion_filter(img, 3);
  
  cv::imwrite("out2.jpg", out);
  cv::imshow("img", img);
  cv::imshow("answer", out);
  cv::waitKey(0);
  cv::destroyAllWindows();

  return 0;
}

12

三、MAX-MIN滤波器

MAX-MIN滤波器使用网格内像素的最大值和最小值的差值对网格内像素重新赋值。通常用于边缘检测。
边缘检测用于检测图像中的线。像这样提取图像中的信息的操作被称为特征提取。
边缘检测通常在灰度图像上进行。

#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
#include <math.h>

// BGR -> Gray
cv::Mat BGR2GRAY(cv::Mat img){
  // get height and width
  int width = img.cols;
  int height = img.rows;

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);

  // each y, x
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      // BGR -> Gray
      out.at<uchar>(y, x) = 0.2126 * (float)img.at<cv::Vec3b>(y, x)[2] \
        + 0.7152 * (float)img.at<cv::Vec3b>(y, x)[1] \
        + 0.0722 * (float)img.at<cv::Vec3b>(y, x)[0];
    }
  }
  return out;
}

// max min filter
cv::Mat max_min_filter(cv::Mat img, int kernel_size){
  int height = img.rows;
  int width = img.cols;
  int channel = img.channels();

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);


  int pad = floor(kernel_size / 2);

  double vmax = 0, vmin = 999, v = 0;

  // filtering  
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      vmax = 0;
      vmin = 999;
      for (int dy = -pad; dy < pad + 1; dy++){
        for (int dx = -pad; dx < pad + 1; dx++){
          if (((y + dy) >= 0) && (( x + dx) >= 0) && ((y + dy) < height) && ((x + dx) < width)){
            v = (double)img.at<uchar>(y + dy, x + dx);
            if (v > vmax){
              vmax = v;
            }
            if (v < vmin){
              vmin = v;
            }
          }
        }
      }
      out.at<uchar>(y, x) = (uchar)(vmax - vmin);
    }
  }
  return out;
}

int main(int argc, const char* argv[]){
  // read image
  cv::Mat img = cv::imread("imori.jpg", cv::IMREAD_COLOR);

  // BGR -> Gray
  cv::Mat gray = BGR2GRAY(img);

  // max min filter
  cv::Mat out = max_min_filter(gray, 3);
  
  cv::imwrite("out3.jpg", out);
  cv::imshow("img", img);
  cv::imshow("answer", out);
  cv::waitKey(0);
  cv::destroyAllWindows();

  return 0;
}

13

四、差分滤波器（Differential Filter）

差分滤波器对图像亮度急剧变化的边缘有提取效果，可以获得邻接像素的差值。

#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
#include <math.h>


// BGR -> Gray
cv::Mat BGR2GRAY(cv::Mat img){
  // get height and width
  int width = img.cols;
  int height = img.rows;

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);

  // each y, x
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      // BGR -> Gray
      out.at<uchar>(y, x) = 0.2126 * (float)img.at<cv::Vec3b>(y, x)[2] \
        + 0.7152 * (float)img.at<cv::Vec3b>(y, x)[1] \
        + 0.0722 * (float)img.at<cv::Vec3b>(y, x)[0];
    }
  }
  return out;
}

// max min filter
cv::Mat diff_filter(cv::Mat img, int kernel_size, bool horizontal){
  int height = img.rows;
  int width = img.cols;
  int channel = img.channels();

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);

  // prepare kernel
  double kernel[kernel_size][kernel_size] = {{0, -1, 0}, {0, 1, 0}, {0, 0, 0}};

  if (horizontal){
    kernel[0][1] = 0;
    kernel[1][0] = -1;
  }

  int pad = floor(kernel_size / 2);

  double v = 0;

  // filtering  
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      v = 0;
      for (int dy = -pad; dy < pad + 1; dy++){
        for (int dx = -pad; dx < pad + 1; dx++){
          if (((y + dy) >= 0) && (( x + dx) >= 0) && ((y + dy) < height) && ((x + dx) < width)){
            v += img.at<uchar>(y + dy, x + dx) * kernel[dy + pad][dx + pad];
          }
        }
      }
      v = fmax(v, 0);
      v = fmin(v, 255);
      out.at<uchar>(y, x) = (uchar)v;
    }
  }
  return out;
}

int main(int argc, const char* argv[]){
  // read image
  cv::Mat img = cv::imread("imori.jpg", cv::IMREAD_COLOR);

  // BGR -> Gray
  cv::Mat gray = BGR2GRAY(img);

  // diff filter (vertical)
  cv::Mat out_v = diff_filter(gray, 3, false);

  // diff filter (horizontal)
  cv::Mat out_h = diff_filter(gray, 3, true);
  
  cv::imwrite("out4-v.jpg", out_v);
  cv::imwrite("out4-h.jpg", out_h);
  cv::imshow("img", img);
  cv::imshow("answer (vertical)", out_v);
  cv::imshow("answer (horizontal)", out_h);
  cv::waitKey(0);
  cv::destroyAllWindows();
 
  return 0;
}

14

五、Sobel滤波器

Sobel滤波器可以提取特定方向（纵向或横向）的边缘。
Sobel算子是在Prewitt算子的基础上改进的，在中心系数上使用一个权值2，相比较Prewitt算子，Sobel模板能够较好的抑制（平滑）噪声。

#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
#include <math.h>


// BGR -> Gray
cv::Mat BGR2GRAY(cv::Mat img){
  // get height and width
  int width = img.cols;
  int height = img.rows;

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);

  // each y, x
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      // BGR -> Gray
      out.at<uchar>(y, x) = 0.2126 * (float)img.at<cv::Vec3b>(y, x)[2] \
        + 0.7152 * (float)img.at<cv::Vec3b>(y, x)[1] \
        + 0.0722 * (float)img.at<cv::Vec3b>(y, x)[0];
    }
  }
  return out;
}

// Sobel filter
cv::Mat sobel_filter(cv::Mat img, int kernel_size, bool horizontal){
  int height = img.rows;
  int width = img.cols;
  int channel = img.channels();

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);

  // prepare kernel
  double kernel[kernel_size][kernel_size] = {{1, 2, 1}, {0, 0, 0}, {-1, -2, -1}};

  if (horizontal){
    kernel[0][1] = 0;
    kernel[2][1] = 0;
    kernel[1][0] = 2;
    kernel[1][2] = -2;
  }

  int pad = floor(kernel_size / 2);

  double v = 0;

  // filtering  
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      v = 0;
      for (int dy = -pad; dy < pad + 1; dy++){
        for (int dx = -pad; dx < pad + 1; dx++){
          if (((y + dy) >= 0) && (( x + dx) >= 0) && ((y + dy) < height) && ((x + dx) < width)){
            v += img.at<uchar>(y + dy, x + dx) * kernel[dy + pad][dx + pad];
          }
        }
      }
      v = fmax(v, 0);
      v = fmin(v, 255);
      out.at<uchar>(y, x) = (uchar)v;
    }
  }
  return out;
}

int main(int argc, const char* argv[]){
  // read image
  cv::Mat img = cv::imread("imori.jpg", cv::IMREAD_COLOR);

  // BGR -> Gray
  cv::Mat gray = BGR2GRAY(img);

  // sobel filter (vertical)
  cv::Mat out_v = sobel_filter(gray, 3, false);

  // sobel filter (horizontal)
  cv::Mat out_h = sobel_filter(gray, 3, true);
  
  cv::imwrite("out5-v.jpg", out_v);
  cv::imwrite("out5-h.jpg", out_h);
  cv::imshow("img", img);
  cv::imshow("answer (vertical)", out_v);
  cv::imshow("answer (horizontal)", out_h);
  cv::waitKey(0);
  cv::destroyAllWindows();
 
  return 0;
}

15

六、Prewitt滤波器

Prewitt滤波器是用于边缘检测的一种滤波器

#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
#include <math.h>


// BGR -> Gray
cv::Mat BGR2GRAY(cv::Mat img){
  // get height and width
  int width = img.cols;
  int height = img.rows;

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);

  // each y, x
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      // BGR -> Gray
      out.at<uchar>(y, x) = 0.2126 * (float)img.at<cv::Vec3b>(y, x)[2] \
        + 0.7152 * (float)img.at<cv::Vec3b>(y, x)[1] \
        + 0.0722 * (float)img.at<cv::Vec3b>(y, x)[0];
    }
  }
  return out;
}

// prewitt filter
cv::Mat prewitt_filter(cv::Mat img, int kernel_size, bool horizontal){
  int height = img.rows;
  int width = img.cols;
  int channel = img.channels();

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);

  // prepare kernel
  double kernel[kernel_size][kernel_size] = {{-1, -1, -1}, {0, 0, 0}, {1, 1, 1}};

  if (horizontal){
    kernel[0][1] = 0;
    kernel[0][2] = 1;
    kernel[1][0] = -1;
    kernel[1][2] = 1;
    kernel[2][0] = -1;
    kernel[2][1] = 0;
  }

  int pad = floor(kernel_size / 2);

  double v = 0;

  // filtering  
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      v = 0;
      for (int dy = -pad; dy < pad + 1; dy++){
        for (int dx = -pad; dx < pad + 1; dx++){
          if (((y + dy) >= 0) && (( x + dx) >= 0) && ((y + dy) < height) && ((x + dx) < width)){
            v += img.at<uchar>(y + dy, x + dx) * kernel[dy + pad][dx + pad];
          }
        }
      }
      v = fmax(v, 0);
      v = fmin(v, 255);
      out.at<uchar>(y, x) = (uchar)v;
    }
  }
  return out;
}

int main(int argc, const char* argv[]){
  // read image
  cv::Mat img = cv::imread("imori.jpg", cv::IMREAD_COLOR);

  // BGR -> Gray
  cv::Mat gray = BGR2GRAY(img);

  // prewitt filter (vertical)
  cv::Mat out_v = prewitt_filter(gray, 3, false);

  // prewitt filter (horizontal)
  cv::Mat out_h = prewitt_filter(gray, 3, true);
  
  cv::imwrite("out6-v.jpg", out_v);
  cv::imwrite("out6-h.jpg", out_h);
  cv::imshow("img", img);
  cv::imshow("answer (vertical)", out_v);
  cv::imshow("answer (horizontal)", out_h);
  cv::waitKey(0);
  cv::destroyAllWindows();
 
  return 0;
}

16

七、Laplacian滤波器

Laplacian滤波器是对图像亮度进行二次微分从而检测边缘的滤波器。

  • 数字图像是离散的， x方向和y方向的一次微分：
    17-1
  • x方向的二次微分：
    17-2
    同理，y方向：
    17-3
  • Laplacian 表达式：
    17-4
#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
#include <math.h>


// BGR -> Gray
cv::Mat BGR2GRAY(cv::Mat img){
  // get height and width
  int width = img.cols;
  int height = img.rows;

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);

  // each y, x
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      // BGR -> Gray
      out.at<uchar>(y, x) = 0.2126 * (float)img.at<cv::Vec3b>(y, x)[2] \
        + 0.7152 * (float)img.at<cv::Vec3b>(y, x)[1] \
        + 0.0722 * (float)img.at<cv::Vec3b>(y, x)[0];
    }
  }
  return out;
}

// laplacian filter
cv::Mat laplacian_filter(cv::Mat img, int kernel_size){
  int height = img.rows;
  int width = img.cols;
  int channel = img.channels();

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);

  // prepare kernel
  double kernel[kernel_size][kernel_size] = {{0, 1, 0}, {1, -4, 1}, {0, 1, 0}};

  int pad = floor(kernel_size / 2);

  double v = 0;

  // filtering  
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      v = 0;
      for (int dy = -pad; dy < pad + 1; dy++){
        for (int dx = -pad; dx < pad + 1; dx++){
          if (((y + dy) >= 0) && (( x + dx) >= 0) && ((y + dy) < height) && ((x + dx) < width)){
            v += img.at<uchar>(y + dy, x + dx) * kernel[dy + pad][dx + pad];
          }
        }
      }
      v = fmax(v, 0);
      v = fmin(v, 255);
      out.at<uchar>(y, x) = (uchar)v;
    }
  }
  return out;
}

int main(int argc, const char* argv[]){
  // read image
  cv::Mat img = cv::imread("imori.jpg", cv::IMREAD_COLOR);

  // BGR -> Gray
  cv::Mat gray = BGR2GRAY(img);

  // laplacian filter
  cv::Mat out = laplacian_filter(gray, 3);
  
  cv::imwrite("out7.jpg", out);
  cv::imshow("img", img);
  cv::imshow("answer", out);
  cv::waitKey(0);
  cv::destroyAllWindows();
 
  return 0;
}

17

八、Emboss滤波器

Emboss滤波器常用于检测图像的边缘和轮廓，能够有效地增强图像的高频信息（边缘和轮廓），并保留图像的低频信息（图像内容）。

#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
#include <math.h>

// BGR -> Gray
cv::Mat BGR2GRAY(cv::Mat img){
  // get height and width
  int width = img.cols;
  int height = img.rows;

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);

  // each y, x
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      // BGR -> Gray
      out.at<uchar>(y, x) = 0.2126 * (float)img.at<cv::Vec3b>(y, x)[2] \
        + 0.7152 * (float)img.at<cv::Vec3b>(y, x)[1] \
        + 0.0722 * (float)img.at<cv::Vec3b>(y, x)[0];
    }
  }
  return out;
}

// emboss filter
cv::Mat emboss_filter(cv::Mat img, int kernel_size){
  int height = img.rows;
  int width = img.cols;
  int channel = img.channels();

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);

  // prepare kernel
  double kernel[kernel_size][kernel_size] = {{-2, -1, 0}, {-1, 1, 1}, {0, 1, 2}};

  int pad = floor(kernel_size / 2);

  double v = 0;

  // filtering  
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      v = 0;
      for (int dy = -pad; dy < pad + 1; dy++){
        for (int dx = -pad; dx < pad + 1; dx++){
          if (((y + dy) >= 0) && (( x + dx) >= 0) && ((y + dy) < height) && ((x + dx) < width)){
            v += img.at<uchar>(y + dy, x + dx) * kernel[dy + pad][dx + pad];
          }
        }
      }
      v = fmax(v, 0);
      v = fmin(v, 255);
      out.at<uchar>(y, x) = (uchar)v;
    }
  }
  return out;
}

int main(int argc, const char* argv[]){
  // read image
  cv::Mat img = cv::imread("imori.jpg", cv::IMREAD_COLOR);

  // BGR -> Gray
  cv::Mat gray = BGR2GRAY(img);

  // emboss filter
  cv::Mat out = emboss_filter(gray, 3);
  
  cv::imwrite("out8.jpg", out);
  cv::imshow("img", img);
  cv::imshow("answer", out);
  cv::waitKey(0);
  cv::destroyAllWindows();
 
  return 0;
}

18

九、LoG滤波器（待完善）

拉普拉斯算子是图像二阶空间导数的二维各向同性测度。拉普拉斯算子可以突出图像中强度发生快速变化的区域，因此常用在边缘检测任务当中。在进行Laplacian操作之前通常需要先用高斯平滑滤波器对图像进行平滑处理，以降低Laplacian操作对于噪声的敏感性。该操作通常是输入一张灰度图，经过处理之后输出一张灰度图。

#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
#include <math.h>

// BGR -> Gray
cv::Mat BGR2GRAY(cv::Mat img){
  // get height and width
  int width = img.cols;
  int height = img.rows;

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);

  // each y, x
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      // BGR -> Gray
      out.at<uchar>(y, x) = 0.2126 * (float)img.at<cv::Vec3b>(y, x)[2] \
        + 0.7152 * (float)img.at<cv::Vec3b>(y, x)[1] \
        + 0.0722 * (float)img.at<cv::Vec3b>(y, x)[0];
    }
  }
  return out;
}

// LoG filter
cv::Mat LoG_filter(cv::Mat img, int kernel_size, double sigma){
  int height = img.rows;
  int width = img.cols;
  int channel = img.channels();

  // prepare output
  cv::Mat out = cv::Mat::zeros(height, width, CV_8UC1);

  // prepare kernel
  int pad = floor(kernel_size / 2);
  double kernel[kernel_size][kernel_size];
  double kernel_sum = 0;
  double _x, _y;
  for (int y = 0; y < kernel_size; y++){
    for (int x = 0; x < kernel_size; x++){
      _y = y - pad;
      _x = x - pad; 
      kernel[y][x] = (_x * _x + _y * _y - sigma * sigma) / (2 * M_PI * pow(sigma, 6)) * exp( - (_x * _x + _y * _y) / (2 * sigma * sigma));
      kernel_sum += kernel[y][x];
    }
  }
  for (int y = 0; y < kernel_size; y++){
    for (int x = 0; x < kernel_size; x++){
      kernel[y][x] /= kernel_sum;
    }
  }

  double v = 0;

  // filtering  
  for (int y = 0; y < height; y++){
    for (int x = 0; x < width; x++){
      v = 0;
      for (int dy = -pad; dy < pad + 1; dy++){
        for (int dx = -pad; dx < pad + 1; dx++){
          if (((y + dy) >= 0) && (( x + dx) >= 0) && ((y + dy) < height) && ((x + dx) < width)){
            v += img.at<uchar>(y + dy, x + dx) * kernel[dy + pad][dx + pad];
          }
        }
      }
      v = fmax(v, 0);
      v = fmin(v, 255);
      out.at<uchar>(y, x) = (uchar)v;
    }
  }
  return out;
}

int main(int argc, const char* argv[]){
  // read image
  cv::Mat img = cv::imread("imori_noise.jpg", cv::IMREAD_COLOR);

  // BGR -> Gray
  cv::Mat gray = BGR2GRAY(img);

  // LoG filter
  cv::Mat out = LoG_filter(gray, 5, 3);
  
  cv::imwrite("out9.jpg", out);
  cv::imshow("img", img);
  cv::imshow("answer", out);
  cv::waitKey(0);
  cv::destroyAllWindows();
 
  return 0;
}

19

j衣l日
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
图像处理 100 问！！
吴建明wujianming_110117
05-27 578
图像处理 100 问！！ 参考链接地址：https://github.com/gzr2017/ImageProcessing100Wen English is here (KuKuXia translates into English) https://github.com/KuKuXia/Image_Processing_100_Questions Chinese is here (gzr2017, my ex-colleague, translates into Chinese) https://git
图像处理100问（Question_01_10）
mrhjlong
09-12 688
感谢分享！ English is here (KuKuXia translates into English) https://github.com/KuKuXia/Image_Processing_100_Questions Chinese is here (gzr2017, my ex-colleague, translates into Chinese) https://github.com/gzr2017/ImageProcessing100Wen 基于c++版本 一、通道交换 RGB -&gt
图像处理一百题（1-10）
狗蛋的博客
05-29 1540
图像处理一百题
图像处理常见问题
YBAdiam的博客
10-28 2925
Matlab编程部分 1. Matlab 中读、写及显示一幅图像的命令各是什么？ 解：第一、Matlab中读图像函数是imread（ ）。imread 函数用于读入各种图像文件，其一般的用法为：[X，MAP]=imread(‘filename’,‘fmt’) 其中，X，MAP分别为读出的图像数据和颜色表数据，fmt为图像的格式，filename为读取的图像文件（可以加上文件的路径）。如：...
Halcon之典型的图像处理问题
weixin_43488529的博客
09-29 1067
典型的图像处理问题1、对图像进行阈值处理2、 边缘检测3、 动态阈值4 、Texture Transformation5、 消除小物体 本章展示了 HALCON 系统为寻找图像处理问题的解决方案所提供的强大功能。 一些典型问题与示例解决方案一起介绍。 1、对图像进行阈值处理 一些最常见的 HALCON 运算符序列可能如下所示： HImage Image("E:/Images/Display/renwu1.jpg"); HRegion Threshold = Image.Threshold(0, 120);
question2.rar_图像锐化_图像锐化增强_拉普拉斯 增强_拉普拉斯锐化_锐化
09-19
在图像处理领域，锐化是一种常见的技术，用于增强图像中的边缘和细节，使其看起来更加清晰。本文将深入探讨“图像锐化”、“图像锐化增强”以及“拉普拉斯增强”或“拉普拉斯锐化”等核心概念，并通过解析提供的...
jsp-ssh.zip_SSH jsp_jsp ssh _multi modal_question answering_基于SS
09-23
多模态问答系统是指能够处理和理解不同形式的信息，如文本、图像、语音等，为用户提供综合的查询解答服务。在这个JSP SSH应用中，可能集成了多种输入和输出方式，以便用户更方便地提出问题和获取答案。 **6. 基于...
基于Visual Question Answerin的视觉图像文本图像处理系统.zip
06-11
Visual Question Answer (VQA) 是对视觉图像的自然语言问答，作为视觉理解 (Visual Understanding) 的一个研究方向，连接着视觉和语言。问题的格式是给定一张图片，并提出关于这张图片的问题，获得该问题的回答。 ...
opencv Mat 类型数据的访问：at<type>(i,j)访问像素值
Magnum的博客
11-07 3297
单通道（灰度图）： int ROWS = 100; // height int COLS = 200; // width Mat img1(ROWS , COLS , CV_32FC1); for (int i=0; i<ROWS ; i++) { for (int j=0; j<COLS ; j++) { img1.at&...
巧解图像处理经典难题之图像配准
AI科技大本营
10-03 7721
（图片付费下载自视觉中国）作者 |白小鱼转载自知乎用户白小鱼【导读】图像配准与相关[1]是图像处理研究领域中的一个典型问题和技术难点，其目的在于比较或融合针对同一对象在...
图像处理常见问题及处理方法
Mei_ZS的博客
11-10 3894
目录 图像去燥 图像增强 图像分割 边缘检测 目标识别 目标追踪 图像去噪 空间域滤波 高斯滤波 中值滤波 频率域滤波 图像增强  直方图均衡 Laplacian Log Gamma 图像分割 基于阈值的分割 固定阈值分割 直方图双峰法 OTSU 基于边缘的分割 基于区域的分割 区域生长 分裂合并 ...
挑战图像处理100问（14）——差分滤波器
qq_42662568的博客
04-10 2085
差分滤波器(Differential Filter) Author: Tian YJ 原图如下： 差分滤波器对图像亮度急剧变化的边缘有提取效果，可以获得邻接像素的差值。 纵向：（用于提取图像的水平线条） K=[0−10010000] K=\left[ \begin{matrix} 0&-1&0\\ 0&1&0\\ 0&0&0 \end{matri...
数字图像处理基本问题清单
Leo的博客
06-26 3761
引用自： 数字图像处理 博客目录索引 - Tony的博客 - 博客频道 - CSDN.NET http://blog.csdn.net/tonyshengtan/article/details/42025919 知识结构图，可能有些分类有些小问题，会持续更新。大图地址：http://download.csdn.net/detail/tonyshengtan/8279157
图像增强及运算篇之顶帽运算和底帽运算
s44359487yad的博客
09-06 801
该系列主要讲解了图像数学形态学知识，结合原理和代码详细介绍了图像腐蚀、图像膨胀、图像开运算和闭运算、图像顶帽运算和图像底帽运算等操作。这篇文章详细介绍了顶帽运算和底帽运算，它们将为后续的图像分割和图像识别提供有效支撑。
OpenCV中的颜色映射函数
jndingxin的专栏
09-02 556
人类的感知并不适合观察灰度图像中的细微变化。人眼更善于观察颜色之间的变化，因此你经常需要将灰度图像重新着色，以便更好地理解它们。OpenCV 现在提供了多种颜色映射，以增强你在计算机视觉应用中的可视化效果。在 OpenCV 中，你只需要使用 applyColorMap 函数就可以在给定的图像上应用一种颜色映射。
使用 OpenCV 和 NumPy 进行图像处理：HSV 范围筛选实现PS抠图效果
最新发布
风凌的博客
09-06 593
以上代码演示了如何使用 OpenCV 和 NumPy 进行基本的图像处理，特别是 HSV 范围筛选。通过这种方法，我们可以提取图像中感兴趣的颜色区域，并在黑色背景上显示它们。这种技术在物体检测和识别、图像分割等应用中非常有用。
图像处理1-10题详解与代码实践
图像处理100题习题与代码集合涵盖了基础到进阶的图像处理概念，旨在帮助学习者深入理解并实践相关技能。本资源由作者LeonG7整理，以GitHub的形式提供，原题库链接为<https://github.com/gzr2017/ImageProcessing100...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值