图像处理算法 实例_c#数字图像处理算法典型实例 - CSDN
  • 经典实时物体追踪算法大全 经典实时物体追踪算法大全 1. 前言 2. 经典实时物体追踪算法描述 3. 代码实现 1. 前言 2. 经典实时物体追踪算法描述 视觉目标跟踪(Visual Object Tracking)是计算机视觉领域的一...

    经典实时物体追踪算法大全

    1. 前言

    2. 经典实时物体追踪算法描述

    视觉目标跟踪(Visual Object Tracking)是计算机视觉领域的一个重要问题。尽管近年来受到了广泛研究,目标跟踪问题由于本身的高难度、高质量数据的稀少,研究热度比目标检测、语义分割等基本视觉任务略低一些。

    OpenCV是一个基于BSD许可(开源)发行的跨平台计算机视觉和机器学习软件库,可以运行在Linux、Windows、Android和Mac OS操作系统上。 [1] 它轻量级而且高效——由一系列 C 函数和少量 C++ 类构成,同时提供了Python、Ruby、MATLAB等语言的接口,实现了图像处理和计算机视觉方面的很多通用算法。目前最新的版本为4.4.0。本实例基于最新版本实现。

    OpenCV提供了以下几种目标追踪算法:

    • 1. CSRT目标追踪算法: 判别相关滤波器(具有通道和空间可靠性)。 趋于比KCF更准确,但速度稍慢

    • 2. KCF目标追踪算法: 核化相关过滤器。 比BOOSTING和MIL更快。 与MIL和KCF相似,不能很好地处理完全遮挡。

    • 3. Boosting目标追踪算法: 基于与用于Haar级联(AdaBoost)背后的机器学习相同的算法,但是像Haar级联一样,它已有十多年的历史了。 该跟踪器运行缓慢,无法正常运行。 仅出于遗留原因并比较其他算法才很有趣。

    • 4. MIL目标追踪算法: 比Boosting追踪算法更好的准确性,但是报告失败的工作很差。

    • 5. TLD目标追踪算法: 不确定TLD跟踪器的OpenCV实施或实际算法本身是否存在问题,但是TLD跟踪器极容易出现假阳性。 因此不建议使用此OpenCV对象跟踪器。

    • 6. MedianFlow目标追踪算法: 对失败报告效果好,但是,如果运动跳动太大(例如快速移动的对象或外观变化很快的对象),则模型将失败。

    • 7. MOSSE目标追踪算法: 非常非常快但不如CSRT或KCF准确,但是如果需要纯速度,则是一个不错的选择。

    • 8. GOTURN目标追踪算法: OpenCV中包含的唯一基于深度学习的对象检测器。

    3. 代码实现

    使用OpenCV实现实时目标追踪,一般经过以下几个步骤:

    • 第一步:创建单目标追踪器
    • 第二步:读取视频的第一帧
    • 第三步:在第一帧中定位物体
    • 第四步:初始化目标追踪器
    • 第五步:更新目标追踪器并展示结果
    from imutils.video import VideoStream
    import argparse
    import imutils
    import time
    import cv2
    
    # 初始化参数
    ap = argparse.ArgumentParser()
    ap.add_argument("-v", "--video",default=0,
    	help="path to input video file")
    ap.add_argument("-t", "--tracker", type=str, default="kcf",
    	help="OpenCV object tracker type")
    args = vars(ap.parse_args())
    
    # 目标追踪实现算法列表
    OPENCV_OBJECT_TRACKERS = {
    	"csrt": cv2.TrackerCSRT_create,
    	"kcf": cv2.TrackerKCF_create,
    	"boosting": cv2.TrackerBoosting_create,
    	"mil": cv2.TrackerMIL_create,
    	"tld": cv2.TrackerTLD_create,
    	"medianflow": cv2.TrackerMedianFlow_create,
    	"mosse": cv2.TrackerMOSSE_create,
    	"goturn": cv2.TrackerGOTURN_create
    }
    
    # 创建多目标追踪器
    trackers = cv2.MultiTracker_create()
    
    # 打开视频流
    if not args.get("video", False):
    	print("[INFO] starting video stream...")
    	vs = VideoStream(src=1).start()
    	time.sleep(1.0)
    else:
    	vs = cv2.VideoCapture("vide.avi")
    
    i = 0
    b = []
    
    while True:
    	# 读取视频帧
    	a = time.time()
    	frame = vs.read()
    	frame = frame[1] if args.get("video", False) else frame
        
    	if frame is None:
    		break
    
    	frame = imutils.resize(frame, width=600)
    
    	# 更新目标追踪器,包括获取目标的坐标位置
    	(success, boxes) = trackers.update(frame)
        # 绘制位置	
    	for box in boxes:
    		if (success == True):
    			(x, y, w, h) = [int(v) for v in box]
    			cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)
    			b.append((time.time()-a)**-1)
    
    	cv2.imshow("Frame", frame)
    	key = cv2.waitKey(1) & 0xFF
    
    	# 选择所要追踪的目标
    	if key == ord("s"):
    		box = cv2.selectROI("Frame", frame, fromCenter=False,
    			showCrosshair=True)
    
    		# 根据需要创建追踪器
    		tracker = OPENCV_OBJECT_TRACKERS[args["tracker"]]()
    		trackers.add(tracker, frame, box)
    		success = True
    
    	elif key == ord("q"):
    		break
            
    	i += 1
    if not args.get("video", False):
    	vs.stop()
    else:
    	vs.release()
    
    cv2.destroyAllWindows()
    

    在这里插入图片描述

    展开全文
  • 一位网友给我发了几张灰度图像,说是他们单位的工业相机拍摄的,画质非常的清楚,他们单位是农业科研单位,特别想知道种子的数量,他想知道的是每次工业相机拍摄种子图片中有多少颗粒种子,想到了用图像处理的办法...

    一位网友给我发了几张灰度图像,说是他们单位的工业相机拍摄的,画质非常的清楚,他们

    单位是农业科研单位,特别想知道种子的数量,他想知道的是每次工业相机拍摄种子图片中

    有多少颗粒种子,想到了用图像处理的办法解决他们的问题,看了他给我照片,以大米种子

    为例。实现了一个简单的算法流程,可以得到种子的数目。

    大致算法分为以下三个步骤:

    1.      将灰度图像二值化,二值化方法可以参考以前的文章,求取像素平均值,灰度直方图都

              可以

    2.      去掉二值化以后的图像中干扰噪声。

    3.      得到种子数目,用彩色标记出来。


    源图像如下:


    程序处理中间结果及最终效果如下:


    二值化处理参见以前的文章 - http://blog.csdn.net/jia20003/article/details/7392325

    大米计数与噪声块消去算法基于连通组件标记算法,源代码如下:

    1. package com.gloomyfish.rice.analysis;  
    2.   
    3. import java.awt.image.BufferedImage;  
    4. import java.util.ArrayList;  
    5. import java.util.Arrays;  
    6. import java.util.HashMap;  
    7.   
    8. import com.gloomyfish.face.detection.AbstractBufferedImageOp;  
    9. import com.gloomyfish.face.detection.FastConnectedComponentLabelAlg;  
    10.   
    11. public class FindRiceFilter extends AbstractBufferedImageOp {  
    12.       
    13.     private int sumRice;  
    14.       
    15.     public int getSumRice() {  
    16.         return this.sumRice;  
    17.     }  
    18.   
    19.     @Override  
    20.     public BufferedImage filter(BufferedImage src, BufferedImage dest) {  
    21.         int width = src.getWidth();  
    22.         int height = src.getHeight();  
    23.   
    24.         if ( dest == null )  
    25.             dest = createCompatibleDestImage( src, null );  
    26.   
    27.         int[] inPixels = new int[width*height];  
    28.         int[] outPixels = new int[width*height];  
    29.         getRGB(src, 00, width, height, inPixels );  
    30.           
    31.         FastConnectedComponentLabelAlg fccAlg = new FastConnectedComponentLabelAlg();  
    32.         fccAlg.setBgColor(0);  
    33.         int[] outData = fccAlg.doLabel(inPixels, width, height);  
    34.         // labels statistic  
    35.         HashMap<Integer, Integer> labelMap = new HashMap<Integer, Integer>();  
    36.         for(int d=0; d<outData.length; d++) {  
    37.             if(outData[d] != 0) {  
    38.                 if(labelMap.containsKey(outData[d])) {  
    39.                     Integer count = labelMap.get(outData[d]);  
    40.                     count+=1;  
    41.                     labelMap.put(outData[d], count);  
    42.                 } else {  
    43.                     labelMap.put(outData[d], 1);  
    44.                 }  
    45.             }  
    46.         }  
    47.           
    48.         // try to find the max connected component  
    49.         Integer[] keys = labelMap.keySet().toArray(new Integer[0]);  
    50.         Arrays.sort(keys);  
    51.         int threshold = 10;  
    52.         ArrayList<Integer> listKeys = new ArrayList<Integer>();  
    53.         for(Integer key : keys) {  
    54.             if(labelMap.get(key) <=threshold){  
    55.                 listKeys.add(key);  
    56.             }  
    57.             System.out.println( "Number of " + key + " = " + labelMap.get(key));  
    58.         }  
    59.         sumRice = keys.length - listKeys.size();  
    60.           
    61.         // calculate means of pixel    
    62.         int index = 0;      
    63.         for(int row=0; row<height; row++) {    
    64.             int ta = 0, tr = 0, tg = 0, tb = 0;    
    65.             for(int col=0; col<width; col++) {    
    66.                 index = row * width + col;    
    67.                 ta = (inPixels[index] >> 24) & 0xff;    
    68.                 tr = (inPixels[index] >> 16) & 0xff;    
    69.                 tg = (inPixels[index] >> 8) & 0xff;    
    70.                 tb = inPixels[index] & 0xff;  
    71.                 if(outData[index] != 0 && validRice(outData[index], listKeys)) {  
    72.                     tr = tg = tb = 255;  
    73.                 } else {  
    74.                     tr = tg = tb = 0;  
    75.                 }  
    76.                 outPixels[index] = (ta << 24) | (tr << 16) | (tg << 8) | tb;  
    77.             }  
    78.         }  
    79.         setRGB( dest, 00, width, height, outPixels );  
    80.         return dest;  
    81.     }  
    82.   
    83.     private boolean validRice(int i, ArrayList<Integer> listKeys) {  
    84.         for(Integer key : listKeys) {  
    85.             if(key == i) {  
    86.                 return false;  
    87.             }  
    88.         }  
    89.         return true;  
    90.     }  
    91.   
    92. }  
    大米着色处理很简单,只是简单RGB固定着色,源码如下:

    1. package com.gloomyfish.rice.analysis;  
    2.   
    3. import java.awt.image.BufferedImage;  
    4.   
    5. import com.gloomyfish.face.detection.AbstractBufferedImageOp;  
    6.   
    7. public class ColorfulRiceFilter extends AbstractBufferedImageOp {  
    8.   
    9.     @Override  
    10.     public BufferedImage filter(BufferedImage src, BufferedImage dest) {  
    11.         int width = src.getWidth();  
    12.         int height = src.getHeight();  
    13.   
    14.         if ( dest == null )  
    15.             dest = createCompatibleDestImage( src, null );  
    16.   
    17.         int[] inPixels = new int[width*height];  
    18.         int[] outPixels = new int[width*height];  
    19.         getRGB(src, 00, width, height, inPixels );  
    20.           
    21.         int index = 0, srcrgb;  
    22.         for(int row=0; row<height; row++) {    
    23.             int ta = 255, tr = 0, tg = 0, tb = 0;    
    24.             for(int col=0; col<width; col++) {   
    25.                 index = row * width + col;    
    26. //                ta = (inPixels[index] >> 24) & 0xff;    
    27. //                tr = (inPixels[index] >> 16) & 0xff;    
    28. //                tg = (inPixels[index] >> 8) & 0xff;    
    29. //                tb = inPixels[index] & 0xff;    
    30.                 srcrgb = inPixels[index] & 0x000000ff;  
    31.                 if(srcrgb > 0 && row < 140) {  
    32.                     tr = 0;  
    33.                     tg = 255;  
    34.                     tb = 0;  
    35.                 } else if(srcrgb > 0 && row >= 140 && row <=280) {  
    36.                     tr = 0;  
    37.                     tg = 0;  
    38.                     tb = 255;  
    39.                 } else if(srcrgb > 0 && row >=280) {  
    40.                     tr = 255;  
    41.                     tg = 0;  
    42.                     tb = 0;  
    43.                 }  
    44.                 else {  
    45.                     tr = tg = tb = 0;  
    46.                 }  
    47.                 outPixels[index] = (ta << 24) | (tr << 16) | (tg << 8) | tb;  
    48.             }  
    49.         }  
    50.         setRGB( dest, 00, width, height, outPixels );  
    51.         return dest;  
    52.     }  
    53. }  
    测试程序UI代码如下:

    1. package com.gloomyfish.rice.analysis;  
    2.   
    3. import java.awt.BorderLayout;  
    4. import java.awt.Color;  
    5. import java.awt.Dimension;  
    6. import java.awt.FlowLayout;  
    7. import java.awt.Graphics;  
    8. import java.awt.Graphics2D;  
    9. import java.awt.Image;  
    10. import java.awt.MediaTracker;  
    11. import java.awt.event.ActionEvent;  
    12. import java.awt.event.ActionListener;  
    13. import java.awt.image.BufferedImage;  
    14. import java.io.File;  
    15. import java.io.IOException;  
    16.   
    17. import javax.imageio.ImageIO;  
    18. import javax.swing.JButton;  
    19. import javax.swing.JComponent;  
    20. import javax.swing.JFileChooser;  
    21. import javax.swing.JFrame;  
    22. import javax.swing.JPanel;  
    23.   
    24. public class MainFrame extends JComponent implements ActionListener {  
    25.     /** 
    26.      *  
    27.      */  
    28.     private static final long serialVersionUID = 1518574788794973574L;  
    29.     public final static String BROWSE_CMD = "Browse...";  
    30.     public final static String NOISE_CMD = "Remove Noise";  
    31.     public final static String FUN_CMD = "Colorful Rice";  
    32.       
    33.     private BufferedImage rawImg;  
    34.     private BufferedImage resultImage;  
    35.     private MediaTracker tracker;  
    36.     private Dimension mySize;  
    37.       
    38.     // JButtons  
    39.     private JButton browseBtn;  
    40.     private JButton noiseBtn;  
    41.     private JButton colorfulBtn;  
    42.   
    43.     // rice number....  
    44.     private int riceNum = -1;  
    45.       
    46.       
    47.     public MainFrame() {  
    48.         JPanel btnPanel = new JPanel();  
    49.         btnPanel.setLayout(new FlowLayout(FlowLayout.LEFT));  
    50.         browseBtn = new JButton("Browse...");  
    51.         noiseBtn = new JButton("Remove Noise");  
    52.         colorfulBtn = new JButton("Colorful Rice");  
    53.           
    54.         browseBtn.setToolTipText("Please select image file...");  
    55.         noiseBtn.setToolTipText("find connected region and draw red rectangle");  
    56.         colorfulBtn.setToolTipText("Remove the minor noise region pixels...");  
    57.           
    58.         // buttons  
    59.         btnPanel.add(browseBtn);  
    60.         btnPanel.add(noiseBtn);  
    61.         btnPanel.add(colorfulBtn);  
    62.           
    63.         // setup listener...  
    64.         browseBtn.addActionListener(this);  
    65.         noiseBtn.addActionListener(this);  
    66.         colorfulBtn.addActionListener(this);  
    67.           
    68.         browseBtn.setEnabled(true);  
    69.         noiseBtn.setEnabled(true);  
    70.         colorfulBtn.setEnabled(true);  
    71.           
    72. //      minX = minY =  10000;  
    73. //      maxX = maxY = -1;  
    74.           
    75.         mySize = new Dimension(500300);  
    76.         JFrame demoUI = new JFrame("Rice Detection Demo");  
    77.         demoUI.getContentPane().setLayout(new BorderLayout());  
    78.         demoUI.getContentPane().add(this, BorderLayout.CENTER);  
    79.         demoUI.getContentPane().add(btnPanel, BorderLayout.SOUTH);  
    80.         demoUI.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
    81.         demoUI.pack();  
    82.         demoUI.setVisible(true);  
    83.     }  
    84.       
    85.     public void paint(Graphics g) {  
    86.         Graphics2D g2 = (Graphics2D) g;  
    87.         if(rawImg != null) {  
    88.             Image scaledImage = rawImg.getScaledInstance(200200, Image.SCALE_FAST);  
    89.             g2.drawImage(scaledImage, 00200200null);  
    90.         }  
    91.         if(resultImage != null) {  
    92.             Image scaledImage = resultImage.getScaledInstance(200200, Image.SCALE_FAST);  
    93.             g2.drawImage(scaledImage, 2100200200null);  
    94.         }  
    95.           
    96.         g2.setPaint(Color.RED);  
    97.         if(riceNum > 0) {  
    98.             g2.drawString("Number of Rice : " + riceNum, 100300);  
    99.         } else {  
    100.             g2.drawString("Number of Rice : Unknown"100300);  
    101.         }  
    102.     }  
    103.     public Dimension getPreferredSize() {  
    104.         return mySize;  
    105.     }  
    106.       
    107.     public Dimension getMinimumSize() {  
    108.         return mySize;  
    109.     }  
    110.       
    111.     public Dimension getMaximumSize() {  
    112.         return mySize;  
    113.     }  
    114.       
    115.     public static void main(String[] args) {  
    116.         new MainFrame();  
    117.     }  
    118.       
    119.     @Override  
    120.     public void actionPerformed(ActionEvent e) {  
    121.         if(BROWSE_CMD.equals(e.getActionCommand())) {  
    122.             JFileChooser chooser = new JFileChooser();  
    123.             chooser.showOpenDialog(null);  
    124.             File f = chooser.getSelectedFile();  
    125.             BufferedImage bImage = null;  
    126.             if(f == nullreturn;  
    127.             try {  
    128.                 bImage = ImageIO.read(f);  
    129.                   
    130.             } catch (IOException e1) {  
    131.                 e1.printStackTrace();  
    132.             }  
    133.               
    134.             tracker = new MediaTracker(this);  
    135.             tracker.addImage(bImage, 1);  
    136.               
    137.             // blocked 10 seconds to load the image data  
    138.             try {  
    139.                 if (!tracker.waitForID(110000)) {  
    140.                     System.out.println("Load error.");  
    141.                     System.exit(1);  
    142.                 }// end if  
    143.             } catch (InterruptedException ine) {  
    144.                 ine.printStackTrace();  
    145.                 System.exit(1);  
    146.             } // end catch  
    147.             BinaryFilter bfilter = new BinaryFilter();  
    148.             rawImg = bfilter.filter(bImage, null);  
    149.             repaint();  
    150.         } else if(NOISE_CMD.equals(e.getActionCommand())) {  
    151.             FindRiceFilter frFilter = new FindRiceFilter();  
    152.             resultImage = frFilter.filter(rawImg, null);  
    153.             riceNum = frFilter.getSumRice();  
    154.             repaint();  
    155.         } else if(FUN_CMD.equals(e.getActionCommand())) {  
    156.             ColorfulRiceFilter cFilter = new ColorfulRiceFilter();  
    157.             resultImage = cFilter.filter(resultImage, null);  
    158.             repaint();  
    159.         } else {  
    160.             // do nothing...  
    161.         }  
    162.           
    163.     }  
    164. }  
    展开全文
  • 图像处理常用算法(基础)

    万次阅读 多人点赞 2018-08-12 23:15:22
    图像灰度不同,边界处一般会有明显的边缘,利用此特征可以分割图像。需要说明的是:边缘和物体间的边界并不等同,边缘指的是图像中像素的值有突变的地方,而物体间的边界指的是现实场景中的存在于物体之间的边界。...

    同图像灰度不同,边界处一般会有明显的边缘,利用此特征可以分割图像。需要说明的是:边缘和物体间的边界并不等同,边缘指的是图像中像素的值有突变的地方,而物体间的边界指的是现实场景中的存在于物体之间的边界。有可能有边缘的地方并非边界,也有可能边界的地方并无边缘,因为现实世界中的物体是三维的,而图像只具有二维信息,从三维到二维的投影成像不可避免的会丢失一部分信息;另外,成像过程中的光照和噪声也是不可避免的重要因素。正是因为这些原因,基于边缘的图像分割仍然是当前图像研究中的世界级难题,目前研究者正在试图在边缘提取中加入高层的语义信息。

            在实际的图像分割中,往往只用到一阶和二阶导数,虽然,原理上,可以用更高阶的导数,但是,因为噪声的影响,在纯粹二阶的导数操作中就会出现对噪声的敏感现象,三阶以上的导数信息往往失去了应用价值。二阶导数还可以说明灰度突变的类型。在有些情况下,如灰度变化均匀的图像,只利用一阶导数可能找不到边界,此时二阶导数就能提供很有用的信息。二阶导数对噪声也比较敏感,解决的方法是先对图像进行平滑滤波,消除部分噪声,再进行边缘检测。不过,利用二阶导数信息的算法是基于过零检测的,因此得到的边缘点数比较少,有利于后继的处理和识别工作。

          各种算子的存在就是对这种导数分割原理进行的实例化计算,是为了在计算过程中直接使用的一种计算单位。

     

     

    1.Sobel算子

            其主要用于边缘检测,在技术上它是以离散型的差分算子,用来运算图像亮度函数的梯度的近似值, Sobel算子是典型的基于一阶导数的边缘检测算子,由于该算子中引入了类似局部平均的运算,因此对噪声具有平滑作用,能很好的消除噪声的影响。Sobel算子对于象素的位置的影响做了加权,与Prewitt算子、Roberts算子相比因此效果更好。

           Sobel算子包含两组3x3的矩阵,分别为横向及纵向模板,将之与图像作平面卷积,即可分别得出横向及纵向的亮度差分近似值。实际使用中,常用如下两个模板来检测图像边缘。

                           

    检测水平边沿 横向模板 :           检测垂直平边沿 纵向模板:

    图像的每一个像素的横向及纵向梯度近似值可用以下的公式结合,来计算梯度的大小。

                                                                                 

    然后可用以下公式计算梯度方向。

                                                                               

     

    在以上例子中,如果以上的角度Θ等于零,即代表图像该处拥有纵向边缘,左方较右方暗。

    缺点是Sobel算子并没有将图像的主题与背景严格地区分开来,换言之就是Sobel算子并没有基于图像灰度进行处理,由于Sobel算子并没有严格地模拟人的视觉生理特征,所以提取的图像轮廓有时并不能令人满意。

     

    2. Isotropic Sobel算子

     

            Sobel算子另一种形式是(Isotropic Sobel)算子,加权平均算子,权值反比于邻点与中心点的距离,当沿不同方向检测边缘时梯度幅度一致,就是通常所说的各向同性Sobel(Isotropic Sobel)算子。模板也有两个,一个是检测水平边沿的 ,另一个是检测垂直平边沿的 。各向同性Sobel算子和普通Sobel算子相比,它的位置加权系数更为准确,在检测不同方向的边沿时梯度的幅度一致。

     

    3. Roberts算子

    罗伯茨算子、Roberts算子是一种最简单的算子,是一种利用局部差分算子寻找边缘的算子,他采用对角线方向相邻两象素之差近似梯度幅值检测边缘。检测垂直边缘的效果好于斜向边缘,定位精度高,对噪声敏感,无法抑制噪声的影响。1963年,Roberts提出了这种寻找边缘的算子。

    Roberts边缘算子是一个2x2的模板,采用的是对角方向相邻的两个像素之差。从图像处理的实际效果来看,边缘定位较准,对噪声敏感。适用于边缘明显且噪声较少的图像分割。Roberts边缘检测算子是一种利用局部差分算子寻找边缘的算子,Robert算子图像处理后结果边缘不是很平滑。经分析,由于Robert算子通常会在图像边缘附近的区域内产生较宽的响应,故采用上述算子检测的边缘图像常需做细化处理,边缘定位的精度不是很高。

     

    4. Prewitt算子

            Prewitt算子是一种一阶微分算子的边缘检测,利用像素点上下、左右邻点的灰度差,在边缘处达到极值检测边缘,去掉部分伪边缘,对噪声具有平滑作用 。其原理是在图像空间利用两个方向模板与图像进行邻域卷积来完成的,这两个方向模板一个检测水平边缘,一个检测垂直边缘。

     对数字图像f(x,y),Prewitt算子的定义如下:

    G(i)=|[f(i-1,j-1)+f(i-1,j)+f(i-1,j+1)]-[f(i+1,j-1)+f(i+1,j)+f(i+1,j+1)]|

    G(j)=|[f(i-1,j+1)+f(i,j+1)+f(i+1,j+1)]-[f(i-1,j-1)+f(i,j-1)+f(i+1,j-1)]|

    则 P(i,j)=max[G(i),G(j)]或 P(i,j)=G(i)+G(j)

    经典Prewitt算子认为:凡灰度新值大于或等于阈值的像素点都是边缘点。即选择适当的阈值T,若P(i,j)≥T,则(i,j)为边缘点,P(i,j)为边缘图像。这种判定是欠合理的,会造成边缘点的误判,因为许多噪声点的灰度值也很大,而且对于幅值较小的边缘点,其边缘反而丢失了。

    Prewitt算子对噪声有抑制作用,抑制噪声的原理是通过像素平均,但是像素平均相当于对图像的低通滤波,所以Prewitt算子对边缘的定位不如Roberts算子。

     

    因为平均能减少或消除噪声,Prewitt梯度算子法就是先求平均,再求差分来求梯度。水平和垂直梯度模板分别为:

    检测水平边沿 横向模板                 检测垂直平边沿 纵向模板:

    该算子与Sobel算子类似,只是权值有所变化,但两者实现起来功能还是有差距的,据经验得知Sobel要比Prewitt更能准确检测图像边缘。

     

    5.Laplacian算子

             Laplace算子是一种各向同性算子,二阶微分算子,在只关心边缘的位置而不考虑其周围的象素灰度差值时比较合适。Laplace算子对孤立象素的响应要比对边缘或线的响应要更强烈,因此只适用于无噪声图象。存在噪声情况下,使用Laplacian算子检测边缘之前需要先进行低通滤波。所以,通常的分割算法都是把Laplacian算子和平滑算子结合起来生成一个新的模板。

     

    拉普拉斯算子也是最简单的各向同性微分算子,具有旋转不变性。一个二维图像函数的拉普拉斯变换是各向同性的二阶导数,定义

                                                                               

    了更适合于数字图像处理,将拉式算子表示为离散形式:

    另外,拉普拉斯算子还可以表示成模板的形式,如下图所示,

     

    离散拉普拉斯算子的模板:, 其扩展模板: 。

     

          拉式算子用来改善因扩散效应的模糊特别有效,因为它符合降制模型。扩散效应是成像过程中经常发生的现象。

          Laplacian算子一般不以其原始形式用于边缘检测,因为其作为一个二阶导数,Laplacian算子对噪声具有无法接受的敏感性;同时其幅值产生算边缘,这是复杂的分割不希望有的结果;最后Laplacian算子不能检测边缘的方向;所以Laplacian在分割中所起的作用包括:(1)利用它的零交叉性质进行边缘定位;(2)确定一个像素是在一条边缘暗的一面还是亮的一面;一般使用的是高斯型拉普拉斯算子(Laplacian of a Gaussian,LoG),由于二阶导数是线性运算,利用LoG卷积一幅图像与首先使用高斯型平滑函数卷积改图像,然后计算所得结果的拉普拉斯是一样的。所以在LoG公式中使用高斯函数的目的就是对图像进行平滑处理,使用Laplacian算子的目的是提供一幅用零交叉确定边缘位置的图像;图像的平滑处理减少了噪声的影响并且它的主要作用还是抵消由Laplacian算子的二阶导数引起的逐渐增加的噪声影响。

     

     

    6.Canny算子

          该算子功能比前面几种都要好,但是它实现起来较为麻烦,Canny算子是一个具有滤波,增强,检测的多阶段的优化算子,在进行处理前,Canny算子先利用高斯平滑滤波器来平滑图像以除去噪声,Canny分割算法采用一阶偏导的有限差分来计算梯度幅值和方向,在处理过程中,Canny算子还将经过一个非极大值抑制的过程,最后Canny算子还采用两个阈值来连接边缘。

    Canny边缘检测算法

    step1: 用高斯滤波器平滑图象;

    step2: 用一阶偏导的有限差分来计算梯度的幅值和方向;

    step3: 对梯度幅值进行非极大值抑制

    step4: 用双阈值算法检测和连接边缘

    详解:http://www.cnblogs.com/cfantaisie/archive/2011/06/05/2073168.html

     

     

    (1)图象边缘检测必须满足两个条件:一能有效地抑制噪声;二必须尽量精确确定边缘的位置。

    (2)根据对信噪比与定位乘积进行测度,得到最优化逼近算子。这就是Canny边缘检测算子。

    (3)类似与Marr(LoG)边缘检测方法,也属于先平滑后求导数的方法。

    展开全文
  • 图像分割基础算法及实现实例

    万次阅读 多人点赞 2016-04-19 17:09:30
    最近的项目涉及到了图像处理领域,小小研究了一番,同时收集资料实现了几个基础功能。 一、图像反转 I=imread('input_image.jpg'); J=double(I); J=-J+(256-1); %图像反转线性变换 H=uint8(J); subplot(3,3,4),...

    最近的项目涉及到了图像处理领域,小小研究了一番,同时收集资料实现了几个基础功能。

    一、图像反转

    I=imread('input_image.jpg');
    J=double(I);
    J=-J+(256-1); %图像反转线性变换
    H=uint8(J);
    subplot(3,3,4),imshow(H);
    title('图像反转线性变换');
    axis([50,250,50,200]);
    axis on;

    二、灰度线性变换

    I=imread('input_image.jpg');
    subplot(3,3,1),imshow(I);
    title('原始图像');
    axis([50,250,50,200]);
    axis on;
    
    I1 = rgb2gray(I);
    subplot(3,3,2),imshow(I1)
    title('灰度图像')
    axis([50,250,50,200]);
    grid on;
    axis on;
    K=imadjust(I1,[0.3 0.7],[]);
    subplot(3,3,3),imshow(K);
    title('线性变换图像[0.3 0.7]');
    axis([50,250,20,200]);
    grid on;
    axis on;
    三、非线性变换

    I=imread('input_image.jpg');
    I1 = rgb2gray(I);
    subplot(3,3,5),imshow(I1);
    title('灰度图像');
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系
    J=double(I1);
    J=40*(log(J+1));
    H=uint8(J);
    subplot(3,3,6),imshow(H);
    title('对数变换图像');
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系

    上述代码结果:


    四、直方图均衡化

    I=imread('input_image.jpg');
    figure;
    I=rgb2gray(I);
    subplot(2,2,1);
    imshow(I);
     
    subplot(2,2,2);
    imhist(I);
    title('直方图均衡化图像');
     
    I1 = histeq(I);
    subplot(2,2,3);
    imshow(I1);
    subplot(2,2,4);
    imhist(I1);

    上述代码结果:


    五、线性平滑滤波器
    I=imread('input_image.jpg');
    figure;
    subplot(231)
    imshow(I)
    title('原始图像')
    I=rgb2gray(I);
    I1=imnoise(I,'salt & pepper',0.02);
    subplot(232)
    imshow(I1)
    title('添加椒盐噪声的图像')
     
    k1=filter2(fspecial('average',3),I1)/255; %进行3*3模板平滑滤波
    k2=filter2(fspecial('average',5),I1)/255; %进行5*5模板平滑滤波
    k3=filter2(fspecial('average',7),I1)/255; %进行7*7模板平滑滤波
    k4=filter2(fspecial('average',9),I1)/255; %进行9*9模板平滑滤波
    subplot(233),imshow(k1);title('3*3模板平滑滤波');
    subplot(234),imshow(k2);title('5*5模板平滑滤波');
    subplot(235),imshow(k3);title('7*7模板平滑滤波');
    subplot(236),imshow(k4);title('9*9模板平滑滤波');

    上述代码结果:


    六、中值滤波器

    figure;
    I=imread('input_image.jpg');
    I=rgb2gray(I);
    subplot(231),imshow(I);
    title('原图像');
     
    J=imnoise(I,'salt & pepper',0.02);
    subplot(232),imshow(J);
    title('添加椒盐噪声图像');
     
    k1=medfilt2(J); %进行3*3模板中值滤波
    k2=medfilt2(J,[5,5]); %进行5*5模板中值滤波
    k3=medfilt2(J,[7,7]); %进行7*7模板中值滤波
    k4=medfilt2(J,[9,9]); %进行9*9模板中值滤波
    subplot(233),imshow(k1);title('3*3模板中值滤波');
    subplot(234),imshow(k2);title('5*5模板中值滤波');
    subplot(235),imshow(k3);title('7*7模板中值滤波');
    subplot(236),imshow(k4);title('9*9模板中值滤波');

    上述代码结果:


    七、用Sobel算子和拉普拉斯对图像锐化

    figure;
    I=imread('input_image.jpg');
    subplot(2,2,1),imshow(I);
    title('原始图像');
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系
    I1=im2bw(I);
    subplot(2,2,2),imshow(I1);
    title('二值图像');
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系
    H=fspecial('sobel'); %选择sobel算子
    J=filter2(H,I1); %卷积运算
    subplot(2,2,3),imshow(J);
    title('sobel算子锐化图像');
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系
     
    I1 = double(I1);
    h=[0 1 0,1 -4 1,0 1 0]; %拉普拉斯算子
    J1=conv2(I1,h,'same'); %卷积运算
    subplot(2,2,4),imshow(J1);
    title('拉普拉斯算子锐化图像');
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系

    上述代码结果:


    八、梯度算子检测边缘

    figure;
    I=imread('input_image.jpg');
    subplot(2,3,1);
    imshow(I);
    title('原始图像');
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系
    I1=im2bw(I);
    subplot(2,3,2);
    imshow(I1);
    title('二值图像');
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系
    I2=edge(I1,'roberts');
     
    subplot(2,3,3);
    imshow(I2);
    title('roberts算子分割结果');
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系
    I3=edge(I1,'sobel');
    subplot(2,3,4);
    imshow(I3);
    title('sobel算子分割结果');
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系
    I4=edge(I1,'Prewitt');
    subplot(2,3,5);
    imshow(I4);
    title('Prewitt算子分割结果');
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系
    九、LOG算子检测边缘
    I1=rgb2gray(I);
    I2=edge(I1,'log');
    subplot(2,3,6);
    imshow(I2);
    title('log算子分割结果');

    上述代码结果:


    十、Canny算子检测边缘
    figure;
    I=imread('input_image.jpg');
    subplot(2,2,1);
    imshow(I);
    title('原始图像')
    I1=rgb2gray(I);
    subplot(2,2,2);
    imshow(I1);
    title('灰度图像');
    I2=edge(I1,'canny');
    subplot(2,2,3);
    imshow(I2);
    title('canny算子分割结果');

    上述代码结果:


    十一、边界跟踪(bwtraceboundary函数)

    I=imread('input_image.jpg');
    figure
    subplot(2,2,1);
    imshow(I);
    title('原始图像');
     
    I1=rgb2gray(I); %将彩色图像转化灰度图像
    threshold=graythresh(I1); %计算将灰度图像转化为二值图像所需的门限
    BW=im2bw(I1, threshold); %将灰度图像转化为二值图像
    subplot(2,2,2);
    imshow(BW);
    title('二值图像');
     
    dim=size(BW);
    col=round(dim(2)/2)-90; %计算起始点列坐标
    row=find(BW(:,col),1); %计算起始点行坐标
    connectivity=8;
    num_points=180;
    contour=bwtraceboundary(BW,[row,col],'N',connectivity,num_points);
    %提取边界
    subplot(2,2,3);
    imshow(I1);
    hold on;
    plot(contour(:,2),contour(:,1), 'g','LineWidth' ,2);
    title('边界跟踪图像');

    上述代码结果:


    十二、Hough变换

    figure;
    I=imread('input_image.jpg');
    rotI=rgb2gray(I);
    subplot(2,2,1);
    imshow(rotI);
    title('灰度图像');
    axis([50,250,50,200]);
    grid on;
    axis on;
    BW=edge(rotI,'prewitt');
    subplot(2,2,2);
    imshow(BW);
    title('prewitt算子边缘检测后图像');
    axis([50,250,50,200]);
    grid on;
    axis on;
    [H,T,R]=hough(BW);
    subplot(2,2,3);
    imshow(H,[],'XData',T,'YData',R,'InitialMagnification','fit');
    title('霍夫变换图');
    xlabel('\theta'),ylabel('\rho');
    axis on , axis normal, hold on;
    P=houghpeaks(H,5,'threshold',ceil(0.3*max(H(:))));
    x=T(P(:,2));y=R(P(:,1));
    plot(x,y,'s','color','white');
    lines=houghlines(BW,T,R,P,'FillGap',5,'MinLength',7);
    subplot(2,2,4);imshow(rotI);
    title('霍夫变换图像检测');
    axis([50,250,50,200]);
    grid on;
    axis on;
    hold on;
    max_len=0;
    for k=1:length(lines)
    xy=[lines(k).point1;lines(k).point2];
    plot(xy(:,1),xy(:,2),'LineWidth',2,'Color','green');
    plot(xy(1,1),xy(1,2),'x','LineWidth',2,'Color','yellow');
    plot(xy(2,1),xy(2,2),'x','LineWidth',2,'Color','red');
    len=norm(lines(k).point1-lines(k).point2);
    if(len>max_len)
    max_len=len;
    xy_long=xy;
    end
    end
    plot(xy_long(:,1),xy_long(:,2),'LineWidth',2,'Color','cyan');

    上述代码结果:


    十三、直方图阈值法

    figure;
    I=imread('input_image.jpg');
    I1=rgb2gray(I);
    subplot(2,2,1);
    imshow(I1);
    title('灰度图像')
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系
    [m,n]=size(I1); %测量图像尺寸参数
    GP=zeros(1,256); %预创建存放灰度出现概率的向量
    for k=0:255
    GP(k+1)=length(find(I1==k))/(m*n); %计算每级灰度出现的概率,将其存入GP中相应位置
    end
    subplot(2,2,2),bar(0:255,GP,'g') %绘制直方图
    title('灰度直方图')
    xlabel('灰度值')
    ylabel('出现概率')
    I2=im2bw(I,150/255);
    subplot(2,2,3),imshow(I2);
    title('阈值150的分割图像')
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系
    I3=im2bw(I,200/255); %
    subplot(2,2,4),imshow(I3);
    title('阈值200的分割图像')
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系

    上述代码结果:


    十四、自动阈值法:Otsu

    clc
    clear all
    figure;
    I=imread('input_image.jpg');
    subplot(1,2,1),imshow(I);
    title('原始图像')
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系
    level=graythresh(I); %确定灰度阈值
    BW=im2bw(I,level);
    subplot(1,2,2),imshow(BW);
    title('Otsu法阈值分割图像')
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系

    上述代码结果:


    十五、膨胀操作

    figure;
    I=imread('input_image.jpg');
    I1=rgb2gray(I);
    subplot(1,2,1);
    imshow(I1);
    title('灰度图像')
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系
    se=strel('disk',1); %生成圆形结构元素
    I2=imdilate(I1,se); %用生成的结构元素对图像进行膨胀
    subplot(1,2,2);
    imshow(I2);
    title('膨胀后图像');
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系

    上述代码结果:


    十六、腐蚀操作

    figure;
    I=imread('input_image.jpg');
    I1=rgb2gray(I);
    subplot(1,2,1);
    imshow(I1);
    title('灰度图像')
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系
    se=strel('disk',1); %生成圆形结构元素
    I2=imerode(I1,se); %用生成的结构元素对图像进行腐蚀
    subplot(1,2,2);
    imshow(I2);
    title('腐蚀后图像');
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系

    上述代码结果:


    十七、开启和闭合操作

    figure;
    I=imread('input_image.jpg');
    subplot(2,2,1),imshow(I);
    title('原始图像');
    axis([50,250,50,200]);
    axis on; %显示坐标系
    I1=rgb2gray(I);
    subplot(2,2,2),imshow(I1);
    title('灰度图像');
    axis([50,250,50,200]);
    axis on; %显示坐标系
    se=strel('disk',1); %采用半径为1的圆作为结构元素
    I2=imopen(I1,se); %开启操作
    I3=imclose(I1,se); %闭合操作
    subplot(2,2,3),imshow(I2);
    title('开启运算后图像');
    axis([50,250,50,200]);
    axis on; %显示坐标系
    subplot(2,2,4),imshow(I3);
    title('闭合运算后图像');
    axis([50,250,50,200]);
    axis on; %显示坐标系

    上述代码结果:


    十八、开启和闭合组合操作
    figure;
    I=imread('input_image.jpg');
    subplot(3,2,1),imshow(I);
    title('原始图像');
    axis([50,250,50,200]);
    axis on; %显示坐标系
    I1=rgb2gray(I);
    subplot(3,2,2),imshow(I1);
    title('灰度图像');
    axis([50,250,50,200]);
    axis on; %显示坐标系
    se=strel('disk',1);
    I2=imopen(I1,se); %开启操作
    I3=imclose(I1,se); %闭合操作
    subplot(3,2,3),imshow(I2);
    title('开启运算后图像');
    axis([50,250,50,200]);
    axis on; %显示坐标系
    subplot(3,2,4),imshow(I3);
    title('闭合运算后图像');
    axis([50,250,50,200]);
    axis on; %显示坐标系
    se=strel('disk',1);
    I4=imopen(I1,se);
    I5=imclose(I4,se);
    subplot(3,2,5),imshow(I5); %开—闭运算图像
    title('开—闭运算图像');
    axis([50,250,50,200]);
    axis on; %显示坐标系
    I6=imclose(I1,se);
    I7=imopen(I6,se);
    subplot(3,2,6),imshow(I7); %闭—开运算图像
    title('闭—开运算图像');
    axis([50,250,50,200]);
    axis on; %显示坐标系

    上述代码结果:


    十九、形态学边界提取
    figure;
    I=imread('input_image.jpg');
    subplot(2,3,1),imshow(I);
    title('原始图像');
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系
    I1=im2bw(I);
    subplot(2,3,2),imshow(I1);
    title('二值化图像');
    axis([50,250,50,200]);
    grid on; %显示网格线
    axis on; %显示坐标系
     
    I2=bwperim(I1); %获取区域的周长
    subplot(2,3,3),imshow(I2);
    title('边界周长的二值图像');
    axis([50,250,50,200]);
    grid on;
    axis on;
     
    I3=bwmorph(I1,'skel',1);
    subplot(2,3,4),imshow(I3);
    title('1次骨架提取');
    axis([50,250,50,200]);
    axis on;
     
    I4=bwmorph(I1,'skel',2);
    subplot(2,3,5),imshow(I4);
    title('2次骨架提取');
    axis([50,250,50,200]);
    axis on;

    上述代码结果:


    展开全文
  • C#数字图像处理算法典型实例高清版本,希望对你有帮助。
  • C#数字图像处理算法典型实例(包含源码)pdf 包含源码
  • 《C#数字图像处理算法典型实例(附光盘)》精选数字图像处理领域中的一些应用实例,以理论和实践相结合的方式,系统地介绍了如何使用C#进行数字图像处理。 共11章,分别讲述了图像的点运算、几何运算、数学形态学...
  • 文档系统地介绍了如何使用C#进行数字图像处理。文档内容清晰,值得拥有!
  • 本资源为C#数字图像处理算法典型实例]一书的随书光盘代码,方便大家学习使用
  • 关于图片的处理 我觉得这可以参考参考 巩固知识点,我也是CSDN自行下载的 积分老贵了这里放一积分 意思下 愿顶
  • C#数字图像处理算法详解大全 原文:C#数字图像处理算法详解大全 C#数字图像处理算法详解大全 网址http://dongtingyueh.blog.163.com/blog/#m=0 分享一个专业的图像处理网站(微像素),...
  • 嵌入式图像处理算法优化

    千次阅读 2017-08-26 16:04:11
    嵌入式图像处理算法优化指南,适用于任何基于ARM或PC平台的视觉应用程序开发 转载2015-08-05 15:09:15 标签:目标识别与跟踪视觉定位与目标识别视觉算法研究与验证视频图像处理开发板it 第一章 绪论 ...
  • 本篇文章将分享图像分类原理,并介绍基于KNN、朴素贝叶斯算法图像分类案例。基础性文章,希望对你有所帮助。同时,该部分知识均为杨秀璋查阅资料撰写,转载请署名CSDN+杨秀璋及原地址出处,谢谢!!
  • 《MATLAB R2016a数字图像处理算法分析与实现》是“精通MATLAB”丛书之一,以MATLAB R2016a为平台编写,通过200多个典型示例介绍利用MATLAB进行数字图像处理算法分析与实现。本书应用性强,实用价值高,提供所有程序...
  • 《精通图像处理经典算法(MATLAB版)》以MATLAB图像处理技术为主线,结合图像处理的典型算法和应用案例,按照从基础理论、算法分析到实际应用的过程进行讲解。不仅涉及数字图像的文件读/写、显示、类型转换、频域...
  • 《精通图像处理经典算法(MATLAB版)》以MATLAB图像处理技术为主线,结合图像处理的典型算法和应用案例,按照从基础理论、算法分析到实际应用的过程进行讲解。不仅涉及数字图像的文件读/写、显示、类型转换、频域...
  • Visual c++数字图像处理典型算法实例源代码,内容包括: 源码目录结构图、256色转灰度图、Hough变换、Walsh变换、二值化变换、亮度增减、傅立叶变换、反色、取对数、取指数、图像平移、图像旋转、图像细化、图像...
  • 常见医学图像处理算法

    千次阅读 2018-01-24 18:57:06
    1,binary dilation,用来去除一些灰度值...2,Otsu’s method,用来对图像进行二值化,可以用来区分前景和背景。利用opencv 代码如下: cv2.threshold(gray_image, 0, 255, cv2.THRESH_OTSU) 3,flood fill algorithm
  • C#数字图像处理算法典型实例(赵春江)光盘内容,非常完整,代码有助学习
  • 《OpenCV图像处理编程实例》以OpenCV开源库为基础实现图像处理领域的很多通用算法,并结合当今图像处理领域前沿技术,对多个典型工程实例进行讲解及实现。全书内容覆盖面广,由基础到进阶,各个技术点均提供详细的...
1 2 3 4 5 ... 20
收藏数 64,499
精华内容 25,799
关键字:

图像处理算法 实例