2017-04-19 19:54:00 The_star_is_at 阅读数 8470

实验三   图像轮廓提取与边缘检测


一、实验目的:

理解并掌握对二值图像进行轮廓提取的相关算法(比如,掏空内部点法),以及用于图像边缘检测和提取的典型微分算子(梯度算子和拉普拉斯算子)。

二、实验环境:

计算机、Windows XP操作系统,Matlab7.0

二、实验内容:

1、根据掏空内部点算法,运用Matlab编程实现二值图像的轮廓提取。

%以下适用于黑色背景白色前景的二值图像轮廓提取(以二值图像circles为例)

BW=imread('circles.png');     %二值图像circlesuint80黑,255

subplot(1,2,1);  imshow(BW);  title('二值图像');

[M, N]=size(BW);     %M行,N

BW_Buffer=BW;

for i=2: M-1

for j=2: N-1

if (BW(i, j)==255 & BW(i-1, j)==255 & BW(i+1, j)==255 & BW(i, j-1)==255 & BW(i, j+1)==255 & BW(i-1, j-1)==255 & BW(i-1, j+1)==255 & BW(i+1, j-1)==255 & BW(i+1, j+1)==255)    %说明BW(i, j)是前景中的一个内部点

       BW_Buffer(i, j)=0;    %掏空该内部点,即将该内部点置成与背景相同灰度

end

end

end

subplot(1,2,2);  imshow(BW_Buffer);  title('提取轮廓');


%以下适用于白色背景黑色前景的二值图像轮廓提取(以二值图像source为例)

BW=imread('source.bmp');      %二值图像sourceuint80黑,255

subplot(1,2,1);  imshow(BW);  title('二值图像');

[M, N]=size(BW);   %M行,N

BW_Buffer=BW;

for i=2: M-1

for j=2: N-1

if (BW(i, j)==0 & BW(i-1, j)==0 & BW(i+1, j)==0 & BW(i, j-1)==0 & BW(i, j+1)==0 & BW(i-1, j-1)==0 & BW(i-1, j+1)==0 & BW(i+1, j-1)==0 & BW(i+1, j+1)==0)      %说明BW(i, j)是前景中的一个内部点

       BW_Buffer(i, j)=255;   %掏空该内部点,即将该内部点置成与背景相同灰度

end

end

end

subplot(1,2,2);  imshow(BW_Buffer);  title('提取轮廓');

注意:使用掏空内部点的方法来提取二值图像的轮廓时,不能直接在原始二值图像矩阵上判断一个点掏空一个点,否则对前面像素的掏空操作会影响到对后面像素的判断结果。

解决方法:创建原始二值图像矩阵的副本(即图像矩阵BW_Buffer),在原始二值图像矩阵上执行判断操作,即依次判断每个像素点是否为前景中的内部点,如果是,则在图像矩阵BW_Buffer上执行掏空内部点的操作。

2、以灰度图像ricecameraman为例,利用Matlab图像处理工具箱中的edge函数,分别使用Roberts 算子、Sobel算子、Prewitt 算子对其进行边缘检测。

(1)函数格式: BW = edge(I, 'method', thresh)

(2)格式说明:edge函数输入灰度图像矩阵I,输出二值图像矩阵BW;参数'method'用于指定所使用的边缘检测算子,可以是'roberts''sobel''prewitt''log''canny';参数thresh用于指定梯度门限值(也称梯度阈值),图像中梯度值大于等于门限值thresh的像素用白色(1)表示,说明这些地方对应边缘,梯度值小于门限值thresh的像素用黑色(0)表示(edge function will ignore all edges that are not stronger than thresh)。若不指定参数thresh,则edge函数会自动选择阈值。所以edge函数最终将原始灰度图像中的边缘和背景用二值图像的形式展现出来,以突出边缘的位置,达到边缘检测的目的。

(3)程序如下:

I=imread('rice.png');

subplot(2,2,1);  imshow(I);  title('原始图像');

[BW1,thresh1]=edge(I,'roberts');  %进行Roberts算子边缘检测并返回门限值

[BW2,thresh2]=edge(I,'sobel');    %进行Sobel算子边缘检测并返回门限值

[BW3,thresh3]=edge(I,'prewitt');  %进行Prewitt算子边缘检测并返回门限值

subplot(2,2,2);  imshow(BW1);  title('Roberts算子边缘检测结果');

subplot(2,2,3);  imshow(BW2);  title('Sobel算子边缘检测结果');

subplot(2,2,4);  imshow(BW3);  title('Prewitt算子边缘检测结果');

若向原始图像中加入随机噪声(比如高斯噪声),之后再对噪声图像分别运用Roberts 算子、Sobel算子、Prewitt 算子、Log算子(高斯-拉普拉斯算子)进行边缘检测,观察检测结果,试比较4种边缘检测算子的抗噪声干扰能力。

I=imread('rice.png');

subplot(2,3,1);  imshow(I);  title('原始图像');

G=imnoise(I, 'gaussian');  %向原始图像中加入高斯噪声

subplot(2,3,2);  imshow(G);  title('噪声图像');

BW1=edge(G, 'roberts');  %进行Roberts算子边缘检测

BW2=edge(G, 'sobel');    %进行Sobel算子边缘检测

BW3=edge(G, 'prewitt');  %进行Prewitt算子边缘检测

BW4=edge(G, 'log');      %进行Log算子边缘检测

subplot(2,3,3);  imshow(BW1);  title('Roberts算子边缘检测结果');

subplot(2,3,4);  imshow(BW2);  title('Sobel算子边缘检测结果');

subplot(2,3,5);  imshow(BW3);  title('Prewitt算子边缘检测结果');

subplot(2,3,6);  imshow(BW4);  title('Log算子边缘检测结果');

2017-10-02 18:09:34 cymy001 阅读数 531

本文内容参考《数字图像处理基础》Wilhelm Burger等著。
根据图像数组获得边缘检测信息,然后循着已检测到的边缘点找到轮廓线。

轮廓跟踪:从那些边缘强度较大的地方开始,沿着两个不同方向跟踪边缘点,直到这两条轨迹相遇并形成一条闭合的轮廓线。(灰度梯度弱——>边缘消失;交叉边缘——>歧义)

边缘图:通过“阈值运算”对一个“图像像素”是否属于边缘点做“二值判断”(这里需要被判断的“图像像素”是指由“各种边缘检测算子得到的边缘强度”,“阈值”可以是固定的,也可以说是自适应的),经过“阈值运算”的结果存为一张“二值的边缘图像”,即“边缘图”。
全局阈值化处理的后处理方法,如霍夫变换,能很好处理不完整的边缘图。

边缘锐化:

从原图像函数f(x)上减去其二阶导数f′′(x)的一部分,如下图:
这里写图片描述
二维函数f(x,y)的拉普拉斯算子

Δf(x,y)=2f2x(x,y)+2f2y(x,y)

由中心差分公式易得
HLx=2f2x(x,y)=(121),HLy=2f2y(x,y)=121

HL=HLx+HLy=010141010

接下来对原图像I,用HL算子滤波,然后再用I减去此滤波结果,即得锐化结果

I˘Iω(HLI)

拉普拉斯滤波器对噪声相当敏感,可以采用预平滑措施(如高斯平滑)减弱噪声的影响。

2018-05-22 17:37:11 tuto7534 阅读数 1814

在实际的运用中,图像的边缘检测和轮廓提取很重要。

public Image<TColor, float> Sobel(
	int xorder,
	int yorder,
	int apertureSize
)其中xorder为X方向的一阶,yorder为y方向的一阶,apertureSize为卷积大小,只能为1,3,5,7;不能为其他的。
拉普拉斯算子
public Image<TColor, float> Laplace(
	int apertureSize
)其中apertureSize为正奇数1,3,5,7
public Image<Gray, byte> Canny(
	double thresh,
	double threshLinking,
	int apertureSize,
	bool l2Gradient
)//其中thresh,threshLinking,两个阈值--高阈值与低阈值。其中apertureSize为正奇数1,3,5,7,l2Gradient为TRUE或flase.

CvInvoke中也是类似

public static void Canny(
	IInputArray image,
	IOutputArray edges,
	double threshold1,
	double threshold2,
	int apertureSize = 3,
	bool l2Gradient = false
) 
进行实例练习:
Emgu.CV.Image<Bgr, Byte> YUAN = new Image<Bgr, Byte>((Bitmap)pictureBox1.Image);
            //  pictureBox2.Image = YUAN.Convert<Gray, Byte>().Canny(180,250).ToBitmap();
            //pictureBox2.Image = YUAN.Convert<Gray, Byte>().Canny(180, 250,5,true).ToBitmap();
            //pictureBox1.Image = YUAN.Convert<Gray, Byte>().Bitmap;
            pictureBox2.Image = YUAN.Canny(120,180, 5, true).Bitmap;
            pictureBox2.Image=YUAN.Sobel(1,0,3).Bitmap;

            pictureBox2.Image = YUAN.Laplace(3).Bitmap;



2019-01-25 21:27:49 qq_34814092 阅读数 833

Java OpenCV-4.0.0 图像处理23 图像轮廓

Java OpenCV-4.0.0 图像轮廓

输入图像转为灰度图像cvtColor
使用Canny进行边缘提取,得到二值图像
使用findContours寻找轮廓
使用drawContours绘制轮廓

package com.xu.image;

import java.util.ArrayList;
import java.util.List;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfPoint;
import org.opencv.core.Scalar;
import org.opencv.highgui.HighGui;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

/**  
 * 
 * @Title: Image.java   
 * @Description: OpenCV-4.0.0 测试文件
 * @Package com.xu.test   
 * @author: xuhyacinth     
 * @date: 2019年12月10日20:17:11
 * @version: V-1.0.0 
 * @Copyright: 2019 xuhyacinth
 *
 */
public class Image {

	static {
		System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
	}

	public static void main(String[] args) {
		contour();
	}

	/**
	 * OpenCV-4.0.0  轮廓发现
	 *
	 * @return: void
	 * @date: 2019年12月10日20:17:11
	 */
	public static void contour() {
	    //1 获取原图
	    Mat src = Imgcodecs.imread("C:\\Users\\xuhya\\Pictures\\qq.jpg");
	    //2 图片灰度化
	    Mat gary = new Mat();
	    Imgproc.cvtColor(src, gary, Imgproc.COLOR_RGB2GRAY);
	    //3 图像边缘处理
	    Mat edges = new Mat();
	    Imgproc.Canny(gary, edges, 200, 500, 3, false);
	    //4 发现轮廓
	    List<MatOfPoint> list = new ArrayList<MatOfPoint>();
	    Mat hierarchy = new Mat();
	    Imgproc.findContours(edges, list, hierarchy, Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE);
	    //5 绘制轮廓
	    for (int i = 0, len = list.size(); i < len; i++) {
	        Imgproc.drawContours(src, list, i, new Scalar(0, 255, 0), 1, Imgproc.LINE_AA);
	    }
	    HighGui.imshow("111", src);
	    HighGui.waitKey(0);
	}

}

在这里插入图片描述

2017-06-09 18:04:28 sinat_28901239 阅读数 8265

形态学轮廓提取

  1. 流程分析
    这里写图片描述
    原图像imgA:
    这里写图片描述
    噪声滤除图像imgB:
    这里写图片描述
    腐蚀处理图像imgC:
    这里写图片描述
    相减操作图像imgD:
    这里写图片描述
    二值化处理结果imgE:
    这里写图片描述

  2. 原理分析:
    2.1膨胀:求像素的局部最大值
    将图像(或图像的一部分区域,我们称之为A)与核(我们称之为B)进行如下卷积操作:
    这里写图片描述
    2.2腐蚀:求像素的局部最小值
    将图像(或图像的一部分区域,我们称之为A)与核(我们称之为B)进行如下卷积操作:
    这里写图片描述
    (膨胀腐蚀原理详细可参见博客:http://blog.sina.com.cn/s/blog_6f57a7150100ooin.html 非常感谢博主的分享。)
    2.3噪声滤除:
    开运算: A∘ B=(A⊝B)⊕B
    闭运算: A·B=(A⊕B)⊝B
    噪声滤除: {[(A⊝B)⊕B]⊕B}⊝B=(A∘ B)·B
    这里写图片描述
    在上图中,(a)是原图像,外部有噪声块,内部有噪声孔,(b)为结构元素,尺寸大于所有噪声块和噪声孔,(c)是用(b)去腐蚀(a)的结果,可见,外部的噪声块被去除;之后用(b)去膨胀(c)两次,得到(e),此时已经去除了内部的噪声孔,在进行一次腐蚀操作,得到和原图一样大小的去噪图像(f)。

  3. 实验对比:
    3.1图像格式对比:
    参数设置:不进行噪声滤除,腐蚀2次,十字核,尺寸3*3
    二值图像;
    这里写图片描述
    灰度图像:
    这里写图片描述
    RGB图像:
    这里写图片描述

    3.2核样式对比:
    参数设置:RGB图像,不进行”噪声滤除”,腐蚀1次,尺寸5*5,二值化阈值100.
    这里写图片描述

    3.3核尺寸对比:
    参数设置:RGB图像,不进行”噪声滤除”,十字型核样式,腐蚀1次,二值化阈值100
    这里写图片描述

    3.4腐蚀次数对比:
    参数设置:RGB图像,不进行”噪声滤除”,十字型核样式,尺寸5*5,二值化阈值100
    这里写图片描述

    3.5噪声滤除强度对比:
    参数设置: RGB图像,十字型,腐蚀1次,核样式,尺寸5*5,二值化阈值100
    这里写图片描述

    3.6对比分析:
    图像格式:RGB格式提取轮廓效果较好,灰度和二值图像信息相对有限。
    核样式:十字型效果最佳,矩形和圆形容易造成噪点。
    核尺寸:尺寸过小,轮廓提取不完整;尺寸过大,容易出现噪点。
    腐蚀次数:腐蚀次数过小,轮廓提取不完整;次数过多,容易出现噪点,且轮廓边缘强度过大。
    噪声滤除:影响把图像轮廓深度信息提取。(标红区域)

  4. 代码:

morphology.h

#pragma once
#include "stdafx.h"
#include "opencv2/highgui/highgui.hpp"
#include <opencv2/opencv.hpp>
#include <iostream>
using namespace cv;
using namespace std;

Mat getKernelMatrix(int shape, Size ksize);//内核矩阵生成
void erodeFun(Mat &src, Mat &dst, Mat kernel, int iterations);//腐蚀操作
void dilateFun(Mat &src, Mat &dst, Mat kernel, int iterations);//膨胀操作
void openFun(Mat &src, Mat &dst, Mat kernel, int iterations);//开操作
void closeFun(Mat &src, Mat &dst, Mat kernel, int iterations);//闭操作
void subtractFun(Mat src, Mat erode_ouput, Mat &externalGradientImg, int threshold);//减操作

morphology.cpp

#include "stdafx.h"
#include "morphology.h"
/*
函数: 获取内核矩阵
参数: shape内核样式(矩形: MORPH_RECT 交叉形十字: MORPH_CROSS 椭圆形: MORPH_ELLIPSE)
        ksize内核大小
*/
Mat getKernelMatrix(int shape, Size ksize) {
    Point center((int)ksize.width / 2, (int)ksize.height / 2);
    int i, j;
    int r = 0, c = 0;//圆参数
    double helperR = 0;//圆参数

    if (ksize == Size(1, 1))//单位内核都是矩形内核
        shape = MORPH_RECT;

    if (shape == MORPH_ELLIPSE)//椭圆形内核参数处理
    {
        r = ksize.height / 2;
        c = ksize.width / 2;
        helperR = r ? 1. / ((double)r*r) : 0;
    }

    Mat kernel(ksize, CV_8U);
    //行遍历
    for (i = 0; i < ksize.height; i++)
    {
        uchar* ptr = kernel.data + i*kernel.step;
        int j1 = 0, j2 = 0;

        //确定每一行1的区间[j1,j2]
        if (shape == MORPH_RECT || (shape == MORPH_CROSS && i == center.y))
            j2 = ksize.width;
        else if (shape == MORPH_CROSS)
            j1 = center.x, j2 = j1 + 1;
        else
        {
            int dy = i - r;
            if (std::abs(dy) <= r)//圆
            {
                int dx = saturate_cast<int>(c*sqrt((r*r - dy*dy)*helperR));
                j1 = std::max(c - dx, 0);
                j2 = std::min(c + dx + 1, ksize.width);
            }
        }
        //赋值操作
        for (j = 0; j < j1; j++)
            ptr[j] = 0;
        for (; j < j2; j++)
            ptr[j] = 1;
        for (; j < ksize.width; j++)
            ptr[j] = 0;
    }

    return kernel;
}

/*
函数: 腐蚀操作
参数: src:原图像
        dst:结果图像
        kernel:核矩阵
        iterations:操作次数
*/
void erodeFun(Mat &src, Mat &dst, Mat kernel, int iterations) {
    //参数判定
    if (iterations == 0) { return; }
    if (kernel.cols == 1 && kernel.rows == 1){ return; }


    Mat_<uchar> kernelMatrix = kernel;
    int HALFKERLEN = kernelMatrix.cols / 2;//正方形
    int KERLEN = kernelMatrix.cols;
    Mat pre = src.clone();
    Mat next = src.clone();

    for (int iterator = 0; iterator < iterations; iterator++) {//腐蚀次数
        for (int i = 0; i<pre.rows; i++)
        {
            for (int j = 0; j < pre.cols; j++)
            {
                //处理每一个像素值的每一个通道
                Vec3b minPixel = pre.at<Vec3b>(i, j);
                //遍历核
                for (int ki = 0; ki < KERLEN; ki++) {
                    for (int kj = 0; kj < KERLEN; kj++) {
                        if ((int)kernelMatrix.at<uchar>(ki, kj) == 1) {//核为1,处理
                            int pi = ki + i - HALFKERLEN;
                            int pj = kj + j - HALFKERLEN;
                            if (pi >= 0 && pi < pre.rows && pj >= 0 && pj < pre.cols)//防止超限
                            {
                                if (pre.at<Vec3b>(pi, pj)[0] < minPixel[0]) {
                                    minPixel[0] = pre.at<Vec3b>(pi, pj)[0];
                                }
                                if (pre.at<Vec3b>(pi, pj)[1] < minPixel[1]) {
                                    minPixel[1] = pre.at<Vec3b>(pi, pj)[1];
                                }
                                if (pre.at<Vec3b>(pi, pj)[2] < minPixel[2]) {
                                    minPixel[2] = pre.at<Vec3b>(pi, pj)[2];
                                }
                            }
                        }
                    }
                }
                next.at<Vec3b>(i, j) = minPixel;
            }
        }
        pre = next.clone();//更新
    }
    dst = next.clone();//更新
}


/*
函数: 膨胀操作
参数: src:原图像
        dst:结果图像
        kernel:核矩阵
        iterations:操作次数
*/
void dilateFun(Mat &src, Mat &dst, Mat kernel, int iterations) {

    Mat_<uchar> kernelMatrix = kernel;
    int HALFKERLEN = kernelMatrix.cols / 2;//正方形
    int KERLEN = kernelMatrix.cols;
    Mat pre = src.clone();
    Mat next = src.clone();

    for (int iterator = 0; iterator < iterations; iterator++) {//膨胀次数
        for (int i = 0; i<pre.rows; i++)
        {
            for (int j = 0; j < pre.cols; j++)
            {
                //处理每一个像素值的每一个通道
                Vec3b maxPixel = pre.at<Vec3b>(i, j);
                //遍历核
                for (int ki = 0; ki < KERLEN; ki++) {
                    for (int kj = 0; kj < KERLEN; kj++) {
                        if ((int)kernelMatrix.at<uchar>(ki, kj) == 1) {//核为1,处理
                            int pi = ki + i - HALFKERLEN;
                            int pj = kj + j - HALFKERLEN;
                            if (pi >= 0 && pi < pre.rows && pj >= 0 && pj < pre.cols)//不超限
                            {
                                if (pre.at<Vec3b>(pi, pj)[0] > maxPixel[0]) {
                                    maxPixel[0] = pre.at<Vec3b>(pi, pj)[0];
                                }
                                if (pre.at<Vec3b>(pi, pj)[1] > maxPixel[1]) {
                                    maxPixel[1] = pre.at<Vec3b>(pi, pj)[1];
                                }
                                if (pre.at<Vec3b>(pi, pj)[2] > maxPixel[2]) {
                                    maxPixel[2] = pre.at<Vec3b>(pi, pj)[2];
                                }
                            }
                        }
                    }
                }
                next.at<Vec3b>(i, j) = maxPixel;
            }
        }
        pre = next.clone();
    }
    dst = next.clone();
}


/*
函数: 开操作
参数: src:原图像
        dst:结果图像
        kernel:核矩阵
        iterations:操作次数
*/
void openFun(Mat &src, Mat &dst, Mat kernel, int iterations) {
    Mat erode = src.clone();
    erodeFun(src, erode, kernel, iterations);   //腐蚀
    dilateFun(erode, dst, kernel, iterations);//膨胀
}

/*
函数: 闭操作
参数: src:原图像
        dst:结果图像
        kernel:核矩阵
        iterations:操作次数
*/
void closeFun(Mat &src, Mat &dst, Mat kernel, int iterations) {
    if (iterations == 0) { return; }
    Mat dilate = src.clone();
    dilateFun(src, dilate, kernel, iterations); //腐蚀
    erodeFun(dilate, dst, kernel, iterations);//膨胀
}


void subtractFun(Mat src, Mat erode_ouput, Mat &externalGradientImg, int threshold) {

    for (int i = 0; i < src.rows; i++) {
        for (int j = 0; j < src.cols; j++) {
            /*cout << (int)src.at<Vec3b>(i, j)[0] << " ";
            cout << (int)src.at<Vec3b>(i, j)[1] << " ";
            cout << (int)src.at<Vec3b>(i, j)[2] << " " << endl;*/
            if (src.at<Vec3b>(i, j)[0] - erode_ouput.at<Vec3b>(i, j)[0] > threshold ||
                src.at<Vec3b>(i, j)[1] - erode_ouput.at<Vec3b>(i, j)[1] > threshold ||
                src.at<Vec3b>(i, j)[2] - erode_ouput.at<Vec3b>(i, j)[2] > threshold) {
                externalGradientImg.at<Vec3b>(i, j)[0] = 255;
                externalGradientImg.at<Vec3b>(i, j)[1] = 255;
                externalGradientImg.at<Vec3b>(i, j)[2] = 255;

            }
            else {
                externalGradientImg.at<Vec3b>(i, j)[0] = 0;
                externalGradientImg.at<Vec3b>(i, j)[1] = 0;
                externalGradientImg.at<Vec3b>(i, j)[2] = 0;
            }

        }
    }
}

main.cpp

#include "stdafx.h"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
#include <stdlib.h>
#include <stdio.h>
#include "morphology.h"

using namespace cv;
/// 全局变量
Mat src, outLineResult;

int kernel_type = 0;//核样式
int const kernel_type_max = 2;
int kernel_size = 0;//核尺寸
int const kernel_size_max= 9;
int erode_times = 0;//腐蚀次数
int const erode_times_max = 5;
int removedetails_times = 0;//去除细节次数
int const removedetails_times_max = 2;

void outLine(int, void*);

int main()
{
    src = imread("test.png");

    if (!src.data)
    {
        return -1;
    }

    /// 创建显示窗口
    namedWindow("Erosion Demo", CV_WINDOW_AUTOSIZE);
    namedWindow("Dilation Demo", CV_WINDOW_AUTOSIZE);
    cvMoveWindow("Dilation Demo", src.cols, 0);

    createTrackbar("核样式:", "Erosion Demo",
        &kernel_type, kernel_type_max,
        outLine);
    createTrackbar("核尺寸:", "Erosion Demo",
        &kernel_size, kernel_size_max,
        outLine);
    createTrackbar("腐蚀次数:", "Erosion Demo",
        &erode_times, erode_times_max,
        outLine);
    createTrackbar("去噪强度:", "Erosion Demo",
        &removedetails_times, removedetails_times_max,
        outLine);
    /// Default start
    outLine(0, 0);


    waitKey(0);
    return 0;
}

/**  @function Erosion  */
void outLine(int, void*)
{
    int type;
    string tpyeStr = "";
    string removeDetailType = "";
    if (kernel_type == 0) { type = MORPH_RECT; tpyeStr = "正方形"; }
    else if (kernel_type == 1) { type = MORPH_CROSS; tpyeStr = "十字形"; }
    else if (kernel_type == 2) { type = MORPH_ELLIPSE; tpyeStr = "圆形"; }

    //输出
    cout << endl<<"----------------------" << endl;
    cout << "  核样式:"<< tpyeStr;
    cout << "  核尺寸:" << kernel_size;
    cout << "  轮廓强度:" << erode_times;
    cout << "  细节去除样式:" << removeDetailType;
    cout << "  细节去除强度:" << removedetails_times;

    Mat element = getKernelMatrix(type, Size(kernel_size, kernel_size));
    Mat erode_ouput,closeResult,openResult;
    erode_ouput = src.clone();
    outLineResult = src.clone();
    openResult = src.clone();
    closeResult = src.clone();
    //噪声滤除
    if (removedetails_times == 1) {
        closeFun(src, closeResult, element, 1);
        openFun(closeResult, openResult, element, 1);
    }
    else if (removedetails_times == 2) {
        openFun(src, openResult, element, 1);//去噪
        closeFun(openResult, closeResult, element, 1);
        openFun(closeResult, openResult, element, 1);//去噪
        closeFun(openResult, closeResult, element, 1);  
    }

    // 腐蚀操作
    erodeFun(closeResult, erode_ouput, element , erode_times);

    //减操作
    subtractFun(closeResult, erode_ouput, outLineResult,50);

    imshow("Erosion Demo", outLineResult);
    cout << "  完成";

}

人脸边缘轮廓提取(下巴、嘴唇)

使用上述方法对人脸进行轮廓提取,调整参数,得到相对最佳的效果,但是会出现下巴和嘴唇提取失败的现象,所以针对这些边缘信息,要自行提取。

  1. 流程分析:
    这里写图片描述

  2. 嘴唇定位&内外轮廓及中心点确认:

    使用人脸特征提取和模式匹配方法去定位嘴唇并确认中心点以及内外轮廓。
    这里写图片描述

  3. 自适应算法确定轮廓点
    这里写图片描述

Step1:确定路径L(i)的起始点start(i)和终止点end(i) 。
Step2:从start(i)向end(i)做步长为1的像素点搜索,每次搜索计算像素梯度值,当梯度值大于设定的阈值时,停止该次搜索,并保存该点为轮廓点。
Step3:确定是否完成搜索:如完成,进行下一步轮廓提取。如果未完成,更新搜索路径L(i+1),转至Step1.

提取结果:
这里写图片描述

改变搜索方向,即可对嘴唇进行轮廓点的提取:
这里写图片描述

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