图像处理一（大津二值化、膨胀、腐蚀）

最新推荐文章于 2024-04-18 17:04:53 发布
最新推荐文章于 2024-04-18 17:04:53 发布
阅读量1.4k 收藏 8
点赞数
分类专栏： 图像处理 文章标签： 计算机视觉
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39107882/article/details/105364622
版权

1：大津二值化

二值化：二值化是将图像使用黑和白两种颜色表示的方法，可以凸显图像的轮廓。
我们将灰度的阈值设置为N来进行二值化,即:
在这里插入图片描述
一张图片采用不同的阀值进行二值化后得到的图像差距很大，如下图所示：
原图：
原图
以下分别是阀值为50、 70、150时二值化的结果：
50
70
150
可以看到只有合适的阀值才能很好的二值化图像，如何自动的确定阀值呢？
大津二值化算法（OTSU）算法是由日本学者OTSU于1979年提出的一种对图像进行二值化的高效算法，作用是确定将图像分成黑白两个部分的阈值。
当取最佳阈值时，背景应该与前景差别最大，关键在于如何选择衡量差别的标准，而在otsu算法中这个衡量差别的标准就是最大类间方差。
大津算法,也被称作最大类间方差法,是一种可以自动确定二值化中阈值的算法：
g：类间方差（那个灰度的g最大，哪个灰度就是需要的阈值t）

g = w0 * (u0 - u)^2 + w1 * (u1 - u)^2
根据上面的关系，可以推出：
g = w0 * w1 * (u0 - u1) ^ 2

然后，遍历每一个灰度值，找到这个灰度值对应的 g，找到最大的 g 对应的 t。
w0：前景像素数量占总像素数量的比例
w1：背景像素数量占总像素数量的比例
u0：前景平均灰度
u1：背景平均灰度
u：平均灰度

大津二值化算法后的图像：
大津二值化
阀值：103
可以明显感受到该阀值能显著的分离前景和背景。

大津二值化代码实现：

#include <opencv2/core.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
#include <math.h>
using namespace std;

// 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;
}

// Gray -> Binary
cv::Mat Binarize_Otsu(cv::Mat gray){
  int width = gray.cols;
  int height = gray.rows;

  // determine threshold
  double w0 = 0, w1 = 0;
  double m0 = 0, m1 = 0;
  double max_sb = 0, sb = 0;
  int th = 0;
  int val;

  // Get threshold
  for (int t = 0; t < 255; t++){
    w0 = 0;
    w1 = 0;
    m0 = 0;
    m1 = 0;
    for (int y = 0; y < height; y++){
      for (int x = 0; x < width; x++){
        val = (int)(gray.at<uchar>(y, x));

        if (val < t){
          w0++;
          m0 += val;
        } else {
          w1++;
          m1 += val;
        }
      }
    }

    m0 /= w0;
    m1 /= w1;
    w0 /= (height * width);
    w1 /= (height * width);
    sb = w0 * w1 * pow((m0 - m1), 2);
    
    if(sb > max_sb){
      max_sb = sb;
      th = t;
    }
  }

  std::cout << "threshold:" << th << std::endl;

  // 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++){
      // Binarize
      if (gray.at<uchar>(y, x) > th){
        out.at<uchar>(y, x) = 255;
      } else {
        out.at<uchar>(y, x) = 0;
      }
    
    }
  }

  return out;
}


int main(int argc, const char* argv[])
{
	if(argc <2)
	{
		cout << "input error" << endl;
		return 0;
	}
  // read image
  cv::Mat img = cv::imread(argv[1], cv::IMREAD_COLOR);

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

  // Gray -> Binary
  cv::Mat out = Binarize_Otsu(gray);
  cv::imwrite("out.jpg", out);

  //cv::imshow("sample", out);
  //cv::waitKey(0);
  //cv::destroyAllWindows();

  return 0;
}

2：膨胀

腐蚀和膨胀是数学形态学上的名词，如果用于图像处理上则就称为图像二值形态学。
腐蚀和膨胀是对白色部分（高亮部分）而言的，需要先对图像进行二值化。膨胀就是图像中的高亮部分进行膨胀，“领域扩张”，效果图拥有比原图更大的高亮区域。腐蚀就是原图中的高亮部分被腐蚀，“领域被蚕食”，效果图拥有比原图更小的高亮区域。
形态学处理理中的膨胀算法如下。对于待操作的像素(x,y),如果（x+1, y）、（x-1, y）、（x, y+1）、（x, y-1）中不论哪一个为255.则像素(x,y)为255。
在这里插入图片描述
换句话说,如果将上面的操作执行两次,则可以扩大两格。
在实际进行形态学处理的时候,待操作的像素与矩阵
在这里插入图片描述
相乘,结果大于255的话,将中心像素设为255.
膨胀的原图、二值化图与膨胀后的图：
原图
大津二值化图
膨胀图
代码实现：

#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;
}

// Gray -> Binary
cv::Mat Binarize_Otsu(cv::Mat gray){
  int width = gray.cols;
  int height = gray.rows;

  // determine threshold
  double w0 = 0, w1 = 0;
  double m0 = 0, m1 = 0;
  double max_sb = 0, sb = 0;
  int th = 0;
  int val;

  // Get threshold
  for (int t = 0; t < 255; t++){
    w0 = 0;
    w1 = 0;
    m0 = 0;
    m1 = 0;
    for (int y = 0; y < height; y++){
      for (int x = 0; x < width; x++){
        val = (int)(gray.at<uchar>(y, x));

        if (val < t){
          w0++;
          m0 += val;
        } else {
          w1++;
          m1 += val;
        }
      }
    }

    m0 /= w0;
    m1 /= w1;
    w0 /= (height * width);
    w1 /= (height * width);
    sb = w0 * w1 * pow((m0 - m1), 2);
    
    if(sb > max_sb){
      max_sb = sb;
      th = t;
    }
  }

  std::cout << "threshold:" << th << std::endl;

  // 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++){
      // Binarize
      if (gray.at<uchar>(y, x) > th){
        out.at<uchar>(y, x) = 255;
      } else {
        out.at<uchar>(y, x) = 0;
      }
    
    }
  }

  return out;
}

// Morphology erode
cv::Mat Morphology_Erode(cv::Mat img, int Erode_time){
  int height = img.cols;
  int width = img.rows;

  // output image
  cv::Mat tmp_img;
  cv::Mat out = img.clone();

  // for erode time
  for (int i = 0; i < Erode_time; i++){
    tmp_img = out.clone();

    // each pixel
    for (int y = 0; y < height; y++){
      for (int x = 0; x < width; x++){
        // check left pixel
        if ((x > 0) && (tmp_img.at<uchar>(y, x - 1) == 255)){
          out.at<uchar>(y, x) = 255;
          continue;
        } 

        // check up pixel
        if ((y > 0) && (tmp_img.at<uchar>(y - 1, x) == 255)){
          out.at<uchar>(y, x) = 255;
          continue;
        }

        // check right pixel
        if ((x < width - 1) && (tmp_img.at<uchar>(y, x + 1) == 255)){
          out.at<uchar>(y, x) = 255;
          continue;
        }

        // check left pixel
        if ((y < height - 1) && (tmp_img.at<uchar>(y + 1, x) == 255)){
          out.at<uchar>(y, x) = 255;
          continue;
        }
      }
    }
  }

  return out;
}


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

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

  // Gray -> Binary
  cv::Mat bin = Binarize_Otsu(gray);
  cv::imwrite("out_bin.jpg", bin);

  // Morphology Erode
  cv::Mat out = Morphology_Erode(bin, 2);

  cv::imwrite("out.jpg", out);
  cv::imshow("sample", out);
  cv::waitKey(0);
  cv::destroyAllWindows();

  return 0;
}

3：腐蚀

腐蚀和膨胀相反。
形态学处理理中的膨胀算法如下。对于待操作的像素(x,y),如果（x+1, y）、（x-1, y）、（x, y+1）、（x, y-1）中不论哪一个不为255.则像素(x,y)为0。
在这里插入图片描述
在实际进行形态学处理的时候,待操作的像素与矩阵
在这里插入图片描述
相乘,结果小于255*4的话,将中心像素设为0.
腐蚀的原图、二值化图与腐蚀后的图：
原图
大津二值化图
腐蚀图
代码实现：

#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;
}

// Gray -> Binary
cv::Mat Binarize_Otsu(cv::Mat gray){
  int width = gray.cols;
  int height = gray.rows;

  // determine threshold
  double w0 = 0, w1 = 0;
  double m0 = 0, m1 = 0;
  double max_sb = 0, sb = 0;
  int th = 0;
  int val;

  // Get threshold
  for (int t = 0; t < 255; t++){
    w0 = 0;
    w1 = 0;
    m0 = 0;
    m1 = 0;
    for (int y = 0; y < height; y++){
      for (int x = 0; x < width; x++){
        val = (int)(gray.at<uchar>(y, x));

        if (val < t){
          w0++;
          m0 += val;
        } else {
          w1++;
          m1 += val;
        }
      }
    }

    m0 /= w0;
    m1 /= w1;
    w0 /= (height * width);
    w1 /= (height * width);
    sb = w0 * w1 * pow((m0 - m1), 2);
    
    if(sb > max_sb){
      max_sb = sb;
      th = t;
    }
  }

  std::cout << "threshold:" << th << std::endl;

  // 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++){
      // Binarize
      if (gray.at<uchar>(y, x) > th){
        out.at<uchar>(y, x) = 255;
      } else {
        out.at<uchar>(y, x) = 0;
      }
    
    }
  }

  return out;
}

// Morphology Dilate
cv::Mat Morphology_Dilate(cv::Mat img, int Dilate_time){
  int height = img.cols;
  int width = img.rows;

  // output image
  cv::Mat tmp_img;
  cv::Mat out = img.clone();

  // for erode time
  for (int i = 0; i < Dilate_time; i++){
    tmp_img = out.clone();

    // each pixel
    for (int y = 0; y < height; y++){
      for (int x = 0; x < width; x++){
        // check left pixel
        if ((x > 0) && (tmp_img.at<uchar>(y, x - 1) == 0)){
          out.at<uchar>(y, x) = 0;
          continue;
        } 

        // check up pixel
        if ((y > 0) && (tmp_img.at<uchar>(y - 1, x) == 0)){
          out.at<uchar>(y, x) = 0;
          continue;
        }

        // check right pixel
        if ((x < width - 1) && (tmp_img.at<uchar>(y, x + 1) == 0)){
          out.at<uchar>(y, x) = 0;
          continue;
        }

        // check left pixel
        if ((y < height - 1) && (tmp_img.at<uchar>(y + 1, x) == 0)){
          out.at<uchar>(y, x) = 0;
          continue;
        }
      }
    }
  }

  return out;
}


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

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

  // Gray -> Binary
  cv::Mat bin = Binarize_Otsu(gray);

  // Morphology Dilate
  cv::Mat out = Morphology_Dilate(bin, 2);

  cv::imwrite("out.jpg", out);
  cv::imshow("sample", out);
  cv::waitKey(0);
  cv::destroyAllWindows();

  return 0;
}

开运算：先进行N次腐蚀再进行N次膨胀，开运算可以用来去除仅存的小块像素。
下面进行一次开运算：
二值化图：
二值化
一次腐蚀后：
erode
接着一次膨胀后：
在这里插入图片描述
闭运算：先进行N次膨胀再进行N次腐蚀，闭运算能够将中断的像素连接起来。
Canny边缘检测之后：
在这里插入图片描述
进行一次闭运算（N=1），先膨胀一次：
在这里插入图片描述
接着腐蚀一次：
在这里插入图片描述

洲上渔者
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
目标检测YOLO实战应用案例100讲-复杂背景下的红外弱小目标检测方法研究（续）
qq_36130719的博客
04-18 311
近年来，得益于红外成像技术的蓬勃发展，红外弱小目标检测技术被广泛应用于各种预警系统和民用安防系统等。本章在阐述红外成像过程的基础上，充分把握红外单帧和序列图像中的背景、弱小目标和噪声的内在特性并进行细致分析，最后讨论了红外弱小目标检测效果评价方法，为接下来的研究提供理论基础。在对高强度杂波边缘类复杂背景下的弱小目标检测时，极易产生大量虚警。因此，针对上述问题，本章根据背景与目标特性提出一种基于区域双邻域显著图（Regional。
大津二值化Python实现
05-29
本人车牌识别项目用到的大津二值化的Python模块实现, 输入二维[0,1.]的浮点灰度图像矩阵, 返回0/1的二值化图像矩阵, 使用掩膜赋值法, 效率较高[pretty good not perfect], 时间复杂度接近于O(1)[得益于Python的矩阵操作优化]
图像处理 | Otsu 阈值分割以及基本形态学处理
qq_45716120的博客
11-27 2649
1、图像分割 —— Otsu 全局阈值分割 1) 实现原理与流程 具体实现步骤如下： 统计图像各个灰度级所包含的像素个数，即归一化直方图； 遍历每一个可能的灰度级，根据1) 中得到的直方图，计算出对应的累计概率以及累计灰度均值； 直接对图像调用 mean() 函数计算出全局灰度均值；再根据累计概率、累计灰度均值以及全局灰度均值计算出类间方差； 结合 max() 函数和 find() 函数找出最大类间方差所对应的各个灰度值，如果有多个灰度值，则取这些灰度值的平均值作为分隔阈值； 通过公式计算出可分性度量，将
数字图像处理（六）形态学处理之腐蚀、膨胀、开运算、闭运算
热门推荐
hjxu2016的博客
06-13 2万+
二值图像形态学运算时图像形态学运算的基础。二值图像形态学运算的过程就是在图像中移动结构元素，将结构元素与其下面重叠部分的图像进行交、并等集合运算。为了确定元素中的参照位置，一般把进行形态学运算时的结构元素的参考点称为原点，且远点可以选择在结构元素之中，也可以选择在结构元素之外。二值图像的形态学处理的基本运算有腐蚀、膨胀、开运算、闭运算，击中与击不中、骨架抽取等。注意，本文所有例子都是24位真彩色图...
《图像处理、分析与机器视觉 第四版》形态学 二值膨胀和腐蚀——学习笔记
超级大洋葱的博客
06-12 1776
文章目录二值膨胀和腐蚀膨胀腐蚀击中击不中变换开运算和闭运算 二值膨胀和腐蚀 黑白点的集合构成了二值图像。假定只考虑黑色像素，其余部分认为是背景。基本的形态学变换是膨胀和腐蚀，由这两个变换可以衍生出更多的形态学运算，如开运算、闭运算和形状分解，等等。 膨胀 形态学变换 膨胀 采用向量加法对两个几何进行合并。膨胀 A+B 是所有向量加之和的集合。 在这个例子中， 膨胀是一种各向同性的（isotropic） 扩张（在所有方向七的行为相同 ）。 这种操作有时还被称为 填充（fill） 或 生长（grow） 。
9--OpenCV:图像基本操作之①阈值②形态学操作(腐蚀\膨胀,开、闭)
zjjaibc的博客
08-29 854
OpenCV基本图形操作①阈值②形态学操作(腐蚀\膨胀,开、闭)
【数字图像处理】二值化图像腐蚀运算与膨胀运算
weixin_30724853的博客
09-16 2728
形态学基本概念 基本思想：用一定形态的结构元素去度量和提取图像中的对应形状，达到分析知识的目的。可用于图像处理的各个方面，包括图像分割、边界检测、特征提取。 结构元素：形态学变换中的基本元素，使为了探测图像的某种结构信息而设计的特定形状和尺寸的图像，称为收集图像结构信息的探针。结构元素有多种类型：如圆形、方形、线型等，可携带知识（形态、大小、灰度和色度信息）来探测、研究图像的结...
【OpenCV】图像二值化处理 腐蚀膨胀 边缘检测 轮廓识别
m0_56051805的博客
07-29 4338
【OpenCV】图像二值化处理 腐蚀膨胀 边缘检测 轮廓识别
二值图像的腐蚀和膨胀
Qzx
11-23 2847
二值图像的腐蚀和膨胀就是将一个结构元素（小型二值图，一般为3*3大小）在一个大的二值图上逐点移动并进行比较，根据比较的结果作出相应处理而已。本程序将骨架默认为白色。      腐蚀：结构元素的白点与要处理的图形对应像素点全部相同，则该点为白色，否则变为黑色（即被腐蚀掉了）；      膨胀：结构元素的白点与要处理的图形对应像素点只要有一个相同，则该点设为白色，否则仍然为黑色。     对二值
图像处理之灰度化，二值化，腐蚀，膨胀
weixin_48262500的博客
10-02 2226
灰度化，在RGB模型中，如果R=G=B时，则彩色表示一种灰度颜色，其中R=G=B的值叫灰度值，因此，灰度图像每个像素只需一个字节存放灰度值。 二值图像（Binary Image）是指将图像上的每一个像素只有两种可能的取值或灰度等级状态 腐蚀就是将图像的边缘腐蚀掉。作用就是将目标的边缘的“毛刺”踢除掉。 膨胀就是将图像的边缘扩大些。作用就是将目标的边缘或者是内部的坑填掉。 使用腐蚀与膨胀，可以使目标表面更平滑。 import cv2 import numpy import numpy as np f
图像灰度、二值化、膨胀和腐蚀（纯Java篇）
YY007H的博客
02-21 3859
在c、c++或者python环境中可以使用opencv非常容易实现图像灰度、二值化、膨胀和腐蚀等功能；但在java环境中，使用opencv来处理相对比较麻烦，简单的操作用opencv处理也相对过重，这里记录下java版图片相关处理。 原图： 1、灰度图 public static void main(String[] args) throws Exception { File file = new File("test.png"); BufferedImage
大津阈值法对图像进行二值化
04-04
用MATLAB写的大津阈值法对图像进行二值化，以便于进一步图像处理
大津法求取二值化阈值 MATLAB
05-08
MATLAB 大津法求取二值化阈值otsu，适用于机器视觉初学者
大津法对图像二值化 otsu
12-17
大津法，著名的二值化选取值域的方法.本代码为MATLAB运行。为上传者自己编写，可以运行。欢迎下载。
图像二值化代码
06-27
图像二值化的代码，可直接运行，无需修改。使用大津法Otsu对图像进行二值化。可设置输出图像为1位图像
YOLOV9目标检测-训练、验证、推理
weixin_47151388的博客
04-17 1154
今天的深度学习方法关注的是如何设计最合适的目标函数，使模型的预测结果最接近地面的真实情况。同时，必须设计一个适当的体系结构，以方便获取足够的预测信息。现有方法忽略了一个事实，即输入数据在逐层进行特征提取和空间变换时，会丢失大量的信息。本文将深入研究数据在深度网络中传输时的重要数据丢失问题，即信息瓶颈和可逆函数。我们提出了可编程梯度信息(PGI)的概念，以应对深度网络实现多个目标所需的各种变化。PGI可以为目标任务提供完整的输入信息来计算目标函数，从而获得可靠的梯度信息来更新网络权值。
目标检测中加入背景样本的思考，基于NanoDetPlus的QualityFocalLoss（原创）
Xavier的博客
04-18 954
在目标检测的很多应用场景中，大多数情况下视野中是不存在检测目标的，但是在这些无目标场景下，又很容易出现误检框。为了解决这个问题，理所当然地会想到把这些无目标场景图像放入训练集中进行训练，但是这样做真的有用吗？我们需要思考一下底层的作用机制，并且进一步分析这种方法的作用有多大？最好可以进行量化分析。
node-v16.12.0-darwin-x64.tar.xz
最新发布
04-23
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
试用Dev Containers的示例项目-Go
04-23
计算机技术是指评价计算机系统的各种知识和技能的总称。它涵盖了计算机硬件、软件、网络和信息安全等方面。计算机技术的发展使我们能够进行高效的数据处理、信息存储和传输。现代计算机技术包括操作系统、数据库管理、编程语言、算法设计等。同时，人工智能、云计算和大数据等新兴技术也在不断推动计算机技术的进步。计算机技术的应用广泛，涵盖了各个领域，如商业、医疗、教育和娱乐等。随着计算机技术的不断革新，我们可以更加高效地实现预期自动化、标准化
halcon二值图像腐蚀膨胀
08-24
在Halcon中，可以使用腐蚀和膨胀操作来处理二值图像。腐蚀操作可以将图像中的白色区域缩小，同时保持物体的整体形状。膨胀操作可以将图像中的白色区域扩大，用于填充物体的空洞或连接不连续的物体。 要在Halcon中进行腐蚀操作，可以使用`erosion1`或`erosionRectangle1`函数。这些函数在指定的结构元素内寻找最小值，并将其应用于图像上的每个像素。例如，下面的代码演示了如何使用`erosion1`函数进行腐蚀操作： ``` read_image(Image, 'image.jpg') threshold(Image, BinaryImage, 128, 255) erosion1(BinaryImage, ErodedImage, 3) ``` 要进行膨胀操作，可以使用`dilation1`或`dilationRectangle1`函数。这些函数在指定的结构元素内寻找最大值，并将其应用于图像上的每个像素。以下是一个示例： ``` read_image(Image, 'image.jpg') threshold(Image, BinaryImage, 128, 255) dilation1(BinaryImage, DilatedImage, 3) ``` 在上述示例中，'image.jpg'是输入图像的文件名，'BinaryImage'是二值化后的图像，'ErodedImage'是腐蚀后的图像，'DilatedImage'是膨胀后的图像。你可以根据需要调整结构元素的大小来控制腐蚀和膨胀的程度。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值