2017-10-04 17:14:21 qq_30311601 阅读数 8639

(这里的二值为0和255)

二值图像的孔洞填充是基于图像形态学操作的基本运算,本文参考数字图像处理(冈萨雷斯著)相关章节的有关内容并结合作者自己的思考,给出了基于C# 二值图像孔洞填充的可行程序。

基础知识:参考数字图像处理 P402-P415

数学形态学的语言是集合论,这里所说的孔洞是二值图像内部八连通点阵组成的闭合圈内的像素点集,孔洞填充的基本步骤如下:
1.确定二值图像像素[0,0]为初始种子点,这里认为[0,0]像素点为背景点,而非某个孔洞内部的点。

2.以种子点为起点,采用形态学膨胀算法对背景进行填充。膨胀到不能膨胀为止。膨胀运算采用四连通结构元。

 

 


四连通结构元(即中心像素为种子,以四连通的方式向周围膨胀):

 

 

3.背景填充结束后,对得到的二值图像取反得到新的二值图像,此时图像为全部孔洞的点集。

4.将第三步骤得到的二值图像与原二值图像相加及得到孔洞填充的结果。

 

这样的算法对于大多数图像有效,然而对于[0,0]位置的像素,若为某孔洞内部的点则无法实现有效的孔洞填充。为了解决这一问题,这里采用拓展图像的方法,即在原图像的上下左右分别增加一行或一列数值为255的像素。使原图像尺寸由a*b 变为(a+2)*(b+2),以增加的四周全部像素或[0,0]处的像素为种子,对原图像进行膨胀运算。

结果如下:(图中未被填充“孔洞”是由于边缘未闭合)

         





2019-04-23 10:31:08 weixin_42181588 阅读数 799

我们在进行图像分割后,分割图像结果有时会有一些小孔洞,如下图所示。今天我们就用python语言基于OpenCV实现孔洞填充。
有孔洞的分割图像
代码实现:

import cv2;
import numpy as np;

'''
图像说明:
图像为二值化图像,255白色为目标物,0黑色为背景
要填充白色目标物中的黑色空洞
'''
def FillHole(imgPath,SavePath):
    im_in = cv2.imread(imgPath, cv2.IMREAD_GRAYSCALE);

    # 复制 im_in 图像
    im_floodfill = im_in.copy()
    
    # Mask 用于 floodFill,官方要求长宽+2
    h, w = im_in.shape[:2]
    mask = np.zeros((h+2, w+2), np.uint8)
    
    # floodFill函数中的seedPoint必须是背景
    isbreak = False
    for i in range(im_floodfill.shape[0]):
        for j in range(im_floodfill.shape[1]):
            if(im_floodfill[i][j]==0):
                seedPoint=(i,j)
                isbreak = True
                break
        if(isbreak):
            break
    # 得到im_floodfill
    cv2.floodFill(im_floodfill, mask, seedPoint, 255);

    # 得到im_floodfill的逆im_floodfill_inv
    im_floodfill_inv = cv2.bitwise_not(im_floodfill)
    # 把im_in、im_floodfill_inv这两幅图像结合起来得到前景
    im_out = im_in | im_floodfill_inv
     
    # 保存结果
    cv2.imwrite(SavePath, im_out)
    

孔洞填充结果如下:
孔洞填充结果图像

附:rgb图像填充孔洞
https://blog.csdn.net/weixin_42181588/article/details/89467590

2016-07-20 14:19:13 hust_bochu_xuchao 阅读数 12382

有的时候,我们需要对图像进行孔洞填充,一般想到的方法都是,使用findcontours函数,查找最外层轮廓,然后画出找到的轮廓。

这确实是一种方法,但似乎不够高效。下面贴出一个函数,可以更好的实现这个功能。

话不多说,上代码。开发环境 opencv2.4.13+vs2013   其他vs或者opencv版本应该也可以跑出来

void chao_fillHole(const cv::Mat srcimage, cv::Mat &dstimage)
{
	Size m_Size = srcimage.size();
	Mat temimage = Mat::zeros(m_Size.height + 2, m_Size.width + 2, srcimage.type());//延展图像  
	srcimage.copyTo(temimage(Range(1, m_Size.height + 1), Range(1, m_Size.width + 1)));
	floodFill(temimage, Point(0, 0), Scalar(255));
	Mat cutImg;//裁剪延展的图像  
	temimage(Range(1, m_Size.height + 1), Range(1, m_Size.width + 1)).copyTo(cutImg);
	dstimage = srcimage | (~cutImg);
}

当你仔细看看这几行代码,就会知道,原理很简单了吧。。

运行效果如图所示



2019-04-23 10:35:18 weixin_42181588 阅读数 543

我们在进行图像分割后,分割图像结果有时会有一些小孔洞,如下图所示。今天我们就用python语言基于OpenCV实现孔洞填充。
含有孔洞的RGB图像
代码实现:

import cv2;
import numpy as np;

def FillHole_RGB(imgPath,SavePath):
    # 读取图像为uint32,之所以选择uint32是因为下面转为0xbbggrr不溢出
    im_in_rgb = cv2.imread(imgPath).astype(np.uint32)
    
    # 将im_in_rgb的RGB颜色转换为 0xbbggrr
    im_in_lbl = im_in_rgb[:,:,0] + (im_in_rgb[:,:,1] << 8) + (im_in_rgb[:,:,2] << 16)
    
    # 将0xbbggrr颜色转换为0,1,2,...
    colors, im_in_lbl_new = np.unique(im_in_lbl, return_inverse=True)

    # 将im_in_lbl_new数组reshape为2维
    im_in_lbl_new = np.reshape(im_in_lbl_new,im_in_lbl.shape)
    
    # 创建从32位im_in_lbl_new到8位colorize颜色的映射
    colorize = np.empty((len(colors), 3), np.uint8)
    colorize[:,0] = (colors & 0x0000FF)
    colorize[:,1] = (colors & 0x00FF00) >> 8
    colorize[:,2] = (colors & 0xFF0000) >> 16
    
    # 输出一下colorize中的color
    print("Colors_RGB: \n",colorize)
    
    # 有几种颜色就设置几层数组,每层数组均为各种颜色的二值化数组
    im_result = np.zeros((len(colors),)+im_in_lbl_new.shape,np.uint8)
    
    # 初始化二值数组
    im_th = np.zeros(im_in_lbl_new.shape,np.uint8)
    
    for i in range(len(colors)):
        for j in range(im_th.shape[0]):
            for k in range(im_th.shape[1]):
                if(im_in_lbl_new[j][k]==i):
                    im_th[j][k] = 255
                else:
                    im_th[j][k] = 0
        # 复制 im_in 图像
        im_floodfill = im_th.copy()
     
        # Mask 用于 floodFill,官方要求长宽+2.
        h, w = im_th.shape[:2]
        mask = np.zeros((h+2, w+2), np.uint8)
        
        isbreak = False
        for m in range(im_floodfill.shape[0]):
            for n in range(im_floodfill.shape[1]):
                if(im_floodfill[m][n]==0):
                    seedPoint=(m,n)
                    isbreak = True
                    break
            if(isbreak):
                break
                
        # 得到im_floodfill
        cv2.floodFill(im_floodfill, mask, seedPoint, 255);
         
        # 得到im_floodfill的逆im_floodfill_inv
        im_floodfill_inv = cv2.bitwise_not(im_floodfill)
         
        # 把im_in、im_floodfill_inv这两幅图像结合起来得到前景
        im_out = im_th | im_floodfill_inv
        im_result[i] = im_out
    
    # rgb结果图像
    im_fillhole = np.zeros((im_in_lbl_new.shape[0],im_in_lbl_new.shape[1],3),np.uint8)
    
    # 之前的颜色映射起到了作用
    for i in range(im_result.shape[1]):
        for j in range(im_result.shape[2]):
            for k in range(im_result.shape[0]):
                if(im_result[k][i][j] == 255):
                    im_fillhole[i][j] = colorize[k]
                    break
    
    # 保存图像
    cv2.imwrite(SavePath, im_fillhole)

孔洞填充结果如下:
在这里插入图片描述

2018-04-22 11:45:37 jkjj2015 阅读数 7032

      matlab中的imfill函数可以方便得实现二值图像的孔洞填充,而在opencv中并没有相同功能的函数。因此,在opencv的基础上编写实现孔洞填充的函数,并且能够设定阈值,对面积大于阈值的孔洞不进行填充。使用形态学重建的算法能够有效地实现孔洞填充,具体算法参照《数字图像处理》第三版9.5.9节,孔洞填充。

    主要实现代码如下所示:其中imfill函数即为空洞填充的实现函数,第一个参数是二值图像(0~1),第二个参数是填充孔洞的阈值。若孔洞面积大于阈值则不填充,反之则填充。

#include "iostream"
#include <opencv2\opencv.hpp>
using namespace std;
using namespace cv;
Mat inv_board(Mat src);
Mat inv_img(Mat src);
void delarea(Mat& bw, int max);
Mat imfill(Mat I, int max);
void main()
{
	Mat scr = imread("2.png");
	Mat I, src_gray, F_B, F_BI_C, temp, H, I_fill;
	cvtColor(scr, src_gray, COLOR_BGR2GRAY);
	threshold(src_gray, I, 0.1, 1,0);
	I_fill = imfill(I,40);
	imshow("原二值图", I * 255);
	imshow("填充图", I_fill*255);
	waitKey(0);
}


Mat imfill(Mat I,int max)
{
	Mat  src_gray, F_B, F_BI_C, temp, H, I_fill;
	I_fill = I.clone();
	Mat F = inv_board(I);
	Mat I_C = inv_img(I);
	Mat element = getStructuringElement(0, Size(3, 3), Point(1, 1));
	while (1)
	{


		dilate(F, F_B, element);
		F_BI_C = F_B.mul(I_C);
		temp = F_BI_C - F;
		if (sum(temp) == Scalar(0))
			break;
		else
			F = F_BI_C.clone();
	}
	H = inv_img(F_BI_C);
	Mat H_IC = H.mul(I_C);
	delarea(H_IC, max);
	for (int i = 0; i < H_IC.rows; i++)
	{
		for (int j = 0; j < H_IC.cols; j++)
		{
			if (H_IC.at<uchar>(i, j) == 1)
				I_fill.at<uchar>(i, j) = 1;
		}
	}
	return I_fill;
}
Mat inv_board(Mat src)
{
	
	int rows = src.rows;
	int cols = src.cols;
	Mat dst = Mat::zeros(rows, cols, CV_8UC1);
	for (int i = 0; i < cols; i++)
	{
		dst.at<uchar>(0, i) = 1 - src.at<uchar>(0, i);
	}
	for (int i = 0; i < cols; i++)
	{
		dst.at<uchar>(rows-1, i) = 1 - src.at<uchar>(rows - 1, i);
	}
	for (int i = 1; i < rows-1; i++)
	{
		dst.at<uchar>(i, 0) = 1 - src.at<uchar>(i, 0);
	}
	for (int i = 1; i < rows - 1; i++)
	{
		dst.at<uchar>(i, cols-1) = 1 - src.at<uchar>(i, cols-1);
	}
	return dst;
}


Mat inv_img(Mat src)
{
	int rows = src.rows;
	int cols = src.cols;
	Mat dst = src.clone();
	for (int i = 0; i < rows; i++)
		for (int j = 0; j < cols; j++)
			dst.at<uchar>(i, j) = 1 - src.at<uchar>(i, j);
	return dst;
}


void delarea(Mat& bw, int max )
{
	Mat bw_copy = bw.clone();
	int flag = 0; 
	Mat H_b, H_bw, temp;
	Mat H = Mat::zeros(bw.size(), bw.type());
	for (int i = 0; i < bw.rows; i++)
	{
		for (int j = 0; j < bw.cols; j++)
		{
			if (bw_copy.at<uchar>(i, j) == 1)
			{
				H.at<uchar>(i, j) = 1;
	Mat element = getStructuringElement(0, Size(3, 3), Point(1, 1));
	while (1)
	{
		dilate(H, H_b, element); 
		H_bw = H_b.mul(bw);
		temp = H_bw - H;
		if (sum(temp) == Scalar(0))
			break;
		else
			H = H_bw.clone();
	}
	bw_copy = bw_copy - H_bw;
    if (sum(H_bw).val[0] > max)
	{
		bw = bw - H_bw;
	}
	H = Mat::zeros(bw.size(), bw.type());
			}
			
		}
	}
}


没有更多推荐了,返回首页