精华内容
下载资源
问答
  • 在数字图像处理中,二值图像占有非常重要的地位,图像的二值化使图像中数据量大为减少,从而能凸显出目标的轮廓。 图像通道。在Photoshop中有一个很重要概念叫图像通道,在RGB色彩模式下就是指那单独的红色、绿色...

    1、介绍。

        二值化。图像二值化( Image Binarization)就是将图像上的像素点的灰度值设置为0或255,也就是将整个图像呈现出明显的黑白效果的过程。在数字图像处理中,二值图像占有非常重要的地位,图像的二值化使图像中数据量大为减少,从而能凸显出目标的轮廓。

        图像通道。在Photoshop中有一个很重要概念叫图像通道,在RGB色彩模式下就是指那单独的红色、绿色、蓝色部分。也就是说,一幅完整的图像,是由红色绿色蓝色三个通道组成的。他们共同作用产生了完整的图像。

        下面我会介绍这7种方法,以下图所示的源图为例。

    2、代码

    import javax.imageio.ImageIO;
    import java.awt.image.BufferedImage;
    import java.io.File;
    
    public class ImgTest {
        private static final byte Gray_Type_Min = 1;//最大值法
        private static final byte Gray_Type_Max = 2;//最小值法
        private static final byte Gray_Type_Average = 3;//平均值法
        private static final byte Gray_Type_Weight = 4;//加权法
        private static final byte Gray_Type_Red = 5;//红色值法
        private static final byte Gray_Type_Green = 6;//绿色值法
        private static final byte Gray_Type_Blue = 7;//蓝色值法
    
        private static final String File_Path = "G:\\xiaojie-java-test\\img\\%s\\%s.jpg";
        private static final String Source_Path = "G:\\xiaojie-java-test\\img\\source.jpg";
    
        public static void main(String[] args) {
            //获取不同通道图片的方法
            toChannelImg();
    
            //先灰度化,再二值化(灰度化暂时使用加权法)
            toBinaryImg(20);
            toBinaryImg(40);
            toBinaryImg(60);
            toBinaryImg(80);
            toBinaryImg(100);
            toBinaryImg(120);
            toBinaryImg(140);
            toBinaryImg(160);
            toBinaryImg(180);
            toBinaryImg(200);
            toBinaryImg(220);
            toBinaryImg(240);
        }
    
        /**
         * 获取不同通道图片的方法
         */
        private static void toChannelImg() {
            try {
                BufferedImage image = ImageIO.read(new File(Source_Path));
                final int imgWidth = image.getWidth();
                final int imgHeight = image.getHeight();
                BufferedImage bufferedImage_red = new BufferedImage(imgWidth, imgHeight, BufferedImage.TYPE_INT_RGB);
                BufferedImage bufferedImage_green = new BufferedImage(imgWidth, imgHeight, BufferedImage.TYPE_INT_RGB);
                BufferedImage bufferedImage_blue = new BufferedImage(imgWidth, imgHeight, BufferedImage.TYPE_INT_RGB);
                //这边因为只是灰度操作,所以内外循环imgWidth和imgHeight可以随便放
                for (int i = 0; i < imgHeight; i++) {
                    for (int j = 0; j < imgWidth; j++) {
                        final int pixel = image.getRGB(j, i);
                        bufferedImage_red.setRGB(j, i, pixel & 0xff0000);
                        bufferedImage_green.setRGB(j, i, pixel & 0x00ff00);
                        bufferedImage_blue.setRGB(j, i, pixel & 0x0000ff);
                        //System.out.print(String.format("%4d ", gray));
                    }
                    //System.out.println();
                }
                ImageIO.write(bufferedImage_red, "JPEG", new File(String.format(File_Path, "三通道-图像通道", "red")));
                Thread.sleep(1);
                ImageIO.write(bufferedImage_green, "JPEG", new File(String.format(File_Path, "三通道-图像通道", "green")));
                Thread.sleep(1);
                ImageIO.write(bufferedImage_blue, "JPEG", new File(String.format(File_Path, "三通道-图像通道", "blue")));
                Thread.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        //先灰度化,再二值化(灰度化暂时使用加权法)
        private static void toBinaryImg(int threshold) {
            try {
                BufferedImage image = ImageIO.read(new File(Source_Path));
                final int imgWidth = image.getWidth();
                final int imgHeight = image.getHeight();
                BufferedImage bufferedImage = new BufferedImage(imgWidth, imgHeight, BufferedImage.TYPE_BYTE_BINARY);
                //这边因为只是灰度操作,所以内外循环imgWidth和imgHeight可以随便放
                for (int i = 0; i < imgHeight; i++) {
                    for (int j = 0; j < imgWidth; j++) {
                        final int pixel = image.getRGB(j, i);
                        final int[] grb = getRgb(pixel);
                        final int gray = getGray(grb, Gray_Type_Weight);
                        bufferedImage.setRGB(j, i, (byte) (gray < threshold ? 0 : 255));
                        //System.out.print(String.format("%4d ", gray));
                    }
                    //System.out.println();
                }
                ImageIO.write(bufferedImage, "JPEG", new File(String.format(File_Path, "单通道-二值图", "binary_" + threshold)));
                Thread.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        //将一个int值转化为3个r、g个b的byte值
        private static int[] getRgb(int pixel) {
            int[] rgb = new int[3];
            rgb[0] = (pixel >> 16) & 0xff;
            rgb[1] = (pixel >> 8) & 0xff;
            rgb[2] = pixel & 0xff;
            return rgb;
        }
    
        //根据不同的灰度化方法,返回byte灰度值
        private static int getGray(int[] rgb, int type) {
            if (type == Gray_Type_Average) {
                return (rgb[0] + rgb[1] + rgb[2]) / 3;   //rgb之和除以3
            } else if (type == Gray_Type_Weight) {
                return (int) (0.3 * rgb[0] + 0.59 * rgb[1] + 0.11 * rgb[2]);
            } else if (type == Gray_Type_Red) {
                return rgb[0];//取红色值
            } else if (type == Gray_Type_Green) {
                return rgb[1];//取绿色值
            } else if (type == Gray_Type_Blue) {
                return rgb[2];//取蓝色值
            }
            //比较三个数的大小
            int gray = rgb[0];
            for (int i = 1; i < rgb.length; i++) {
                if (type == Gray_Type_Min) {
                    if (gray > rgb[i]) {
                        gray = rgb[i];//取最小值
                    }
                } else if (type == Gray_Type_Max) {
                    if (gray < rgb[i]) {
                        gray = rgb[i];//取最大值
                    }
                }
            }
            return gray;
        }
    }

    3、结果。

     

    展开全文
  • Python处理图片

    千次阅读 2019-04-29 21:37:14
    python处理图片 有两种相关处理图片的方法:python-opencv和PIL(Image) python-opencv: 1.图像读入: 第一种方法:使用cv2.cv的LoadImage、ShowImage和SaveImage函数 import cv2.cv as cv # 读图片 image=cv....

    1. 有两种相关处理图片的方法:Python-opencv和PIL(Image)

    1.1 Python-opencv

    1.1.1 图像读入
    • 第一种方法:使用cv2.cv的LoadImageShowImageSaveImage函数
    import cv2.cv as cv
    
    # 读图片
    image=cv.LoadImage('img/image.png', cv.CV_LOAD_IMAGE_COLOR)#Load the image
    #Or just: image=cv.LoadImage('img/image.png')
    
    cv.NamedWindow('a_window', cv.CV_WINDOW_AUTOSIZE) #Facultative
    cv.ShowImage('a_window', image) #Show the image
    
    # 写图片
    cv.SaveImage("thumb.png", thumb)
    cv.WaitKey(0) #Wait for user input and quit
    
    • 第二种方法:使用cv2的imreadimwriteimshow函数
    import numpy as np
    import cv2
    
    img = cv2.imread('messi5.jpg',0)
    cv2.imshow('image',img)
    k = cv2.waitKey(0)
    if k == 27:         # wait for ESC key to exit
       cv2.destroyAllWindows()
    elif k == ord('s'): # wait for 's' key to save and exit
       cv2.imwrite('messigray.png',img)
       cv2.destroyAllWindows()
    

    为了加快处理速度,在图像处理算法中,往往首先需要把彩色图像转换为灰度图像。

    1.1.2 进行灰度处理

    灰度数字图像是每个像素只有一个采样颜色的图像,这类图像通常显示为从最暗黑色到最亮的白色的灰度。

    灰度图像与黑白图像不同,在计算机图像领域中黑白图像只有黑白两种颜色,灰度图像在黑色与白色之间还有许多级的颜色深度。

    在RGB模型中,如果R=G=B时,则彩色表示一种灰度颜色,其中R=G=B的值叫灰度值。

    图像灰度化的算法主要有以下4种:

    1)分量法:将彩色图像中的三分量的亮度作为三个灰度图像的灰度值,可根据应用需要选取一种灰度图像。
    
    2)最大值法:使转化后的R,G,B得值等于转化前3个值中最大的一个,即:R=G=B=max(R,G,B)。这种方法转换的灰度图亮度很高。
    
     3)平均值法:是转化后R,G,B的值为转化前R,G,B的平均值。即:R=G=B=(R+G+B)/3。这种方法产生的灰度图像比较柔和。
    
     4)加权平均值法:按照一定权值,对R,G,B的值加权平均,即:![这里写图片描述](https://img-blog.csdn.net/20180106195145267?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvcXFfMzk1MDc0NDU=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)分别为R,G,B的权值,取不同的值形成不同的灰度图像。由于人眼对绿色最为敏感,红色次之,对蓝色的敏感性最低,因此使将得到较易识别的灰度图像。一般时,得到的灰度图像效果最好。 
    

    Python-opencv代码实现灰度处理:

    #第一种方法(分量法)
    #导入opencv库
    import cv2.cv as cv
    #打开图片
    image = cv.LoadImage('mao.jpg')
    #函数cv.CreateImage()创建图像首地址,并分配存储空间
    b = cv.CreateImage(cv.GetSize(image), image.depth, 1)
    g = cv.CloneImage(b)
    r = cv.CloneImage(b)
    cv.Split(image, b, g, r, None)
    cv.ShowImage('a_window', r)
        
    cv.WaitKey(0)
    
    #第二种方法(最大值法)
    image = cv.LoadImage('mao.jpg')
    new = cv.CreateImage(cv.GetSize(image), image.depth, 1)
    for i in range(image.height):
        for j in range(image.width):
            new[i,j] = max(image[i,j][0], image[i,j][1], image[i,j][2])
    cv.ShowImage('a_window', new)
    cv.WaitKey(0)
    
    #第三种方法(平均值法)
    image = cv.LoadImage('mao.jpg')
    new = cv.CreateImage(cv.GetSize(image), image.depth, 1)
    for i in range(image.height):
        for j in range(image.width):
            new[i,j] = (image[i,j][0] + image[i,j][1] + image[i,j][2])/3
    cv.ShowImage('a_window', new)
    cv.WaitKey(0)
    
    
    #第四种方法(加权平均法)
    image = cv.LoadImage('mao.jpg')
    new = cv.CreateImage(cv.GetSize(image), image.depth, 1)
    for i in range(image.height):
        for j in range(image.width):
            new[i,j] = 0.3 * image[i,j][0] + 0.59 * image[i,j][1] +  0.11 * image[i,j][2]
    cv.ShowImage('a_window', new)
    cv.WaitKey(0)
    
    1.1.3 二值化处理

    图像二值化就是将图像上的像素点的灰度值设置为0或255,也就是将整个图像呈现出明显的黑白效果。

    将256个亮度等级的灰度图像通过适当的阈值选取而获得仍然可以反映图像整体和局部特征的二值化图像。

    图像的二值化有利于图像的进一步处理,使图像变得简单,而且数据量减小,能凸显出感兴趣的目标的轮廓。

    二值化处理:将一个像素点的值突出为0,255,使得图片呈现黑白两种颜色。在灰度图像中像素值在0~255,二值化后图像中像素值为0或255。

    在将图像二值化之前需要将其先灰度化, 然后才能进行二值化处理。

    第一种方法:

    import cv2.cv as cv
    image = cv.LoadImage('mao.jpg')
     
    new = cv.CreateImage(cv.GetSize(image), image.depth, 1)
    for i in range(image.height):
        for j in range(image.width):
            new[i,j] = max(image[i,j][0], image[i,j][1], image[i,j][2])
     
    cv.Threshold(new, new, 10, 255, cv.CV_THRESH_BINARY_INV)
    cv.ShowImage('a_window', new)
    cv.WaitKey(0)
    

    第二种方法:

    import cv2 #导入cv2包
    path = 'd:\\testdata\\test\\test1.jpg'  #图片路径
    
    #adaptive threshold
    img=cv2.imread(path)
    im_gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)  #转换成灰度图
    im_at_mean = cv2.adaptiveThreshold(im_gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C , cv2.THRESH_BINARY, 5, 10) #使用自适应阈值进行二值化处理,其他二值化方法可查询API使用
    
    cv2.imshow('image', im_at_mean)
    cv2.show()
    

    ①cv2.cvtColor() 将输入图像转成灰度图
    ②adaptiveThreshold( src, maxValue, adaptiveMethod, thresholdType, blockSize, C[, dst] )将输入图像进行自适应阈值的二值化处理。其中blockSize是用来计算阈值的区域大小,C是从平均值或加权平均值中减去得到的常量。


    例子:

    # -*- coding=GBK -*-
    import cv2 as cv
    import numpy as np
     
     
    #图像二值化 0白色 1黑色
    #全局阈值
    def threshold_image(image):
        gray = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
        cv.imshow("原来", gray)
     
        ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU)#大律法,全局自适应阈值 参数0可改为任意数字但不起作用
        print("阈值:%s" % ret)
        cv.imshow("OTSU", binary)
     
        ret, binary = cv.threshold(gray, 0, 255, cv.THRESH_BINARY | cv.THRESH_TRIANGLE)#TRIANGLE法,,全局自适应阈值, 参数0可改为任意数字但不起作用,适用于单个波峰
        print("阈值:%s" % ret)
        cv.imshow("TRIANGLE", binary)
     
        ret, binary = cv.threshold(gray, 150, 255, cv.THRESH_BINARY)# 自定义阈值为150,大于150的是白色 小于的是黑色
        print("阈值:%s" % ret)
        cv.imshow("自定义", binary)
     
        ret, binary = cv.threshold(gray, 150, 255, cv.THRESH_BINARY_INV)# 自定义阈值为150,大于150的是黑色 小于的是白色
        print("阈值:%s" % ret)
        cv.imshow("自定义反色", binary)
     
        ret, binary = cv.threshold(gray, 150, 255, cv.THRESH_TRUNC)# 截断 大于150的是改为150  小于150的保留
        print("阈值:%s" % ret)
        cv.imshow("截断1", binary)
     
        ret, binary = cv.threshold(gray, 150, 255, cv.THRESH_TOZERO)# 截断 小于150的是改为150  大于150的保留
        print("阈值:%s" % ret)
        cv.imshow("截断2", binary)
     
    src = cv.imread("C://1.jpg")
    threshold_image(src)
    cv.waitKey(0)
    cv.destroyAllWindows()
    

    在这里插入图片描述

    1.1.4 降噪

    在处理图像识别问题中,处理图片噪点,像周围的一些细节很丰富,小的黑白点交错。但是,这些“细节”是我们在真正使用时,所不需要的,会影响我们对主要特征的提取,因此我们一般都要进行降噪处理。

    (1)将每个像素替换为该像素周围像素的均值。这样就可以平滑并替代那些强度变化明显的区域。

    result = cv2.blur(image,(5,5))
     
    #上为均值模糊去噪方法。周围的都为均值
    #又称为低通滤波
     
    gaussianResult = cv2.GaussianBlur(img,(5,5),1.5)
     
    #上为高斯模糊去噪方法。在某些情况下,需要对一个像素的周围的像素给予更多的重视。因此,可通过分配权重来重新计算这些周围点的值。
    #(5,5)不可以随意指定,只能指定1,3,5,7.....等数字
    

    (2滤波与高斯滤波的不同之处在于:低通滤波中,滤波器中每个像素的权重是相同的,即滤波器是线性的。而高斯滤波器中像素的权重与其距中心像素的距离成比例。

    还有一种去噪方法为中值滤波器。(主要用来处理图像中的椒盐现象)

    result = cv2.medianBlur(image,5)
    
    1.1.5 剪裁

    使用OpenCV的findContours获取轮廓并切割(python)

    (1)获取轮廓

    OpenCV2获取轮廓主要是用cv2.findContours

    import numpy as np
    import cv2
    
    im = cv2.imread('test.jpg')
    imgray = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
    ret,thresh = cv2.threshold(imgray,127,255,0)
    #查找检测物体的轮廓
    image, contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
    

    (2)画出轮廓

    为了看到自己画了哪些轮廓,可以使用 cv2.boundingRect()函数获取轮廓的范围,即左上角原点,以及他的高和宽。然后用cv2.rectangle()方法画出矩形轮廓

    for i in range(0,len(contours)):  
        # 画出矩形(图片,矩形左上角,矩形右下角,线框的颜色,线宽)
        x, y, w, h = cv2.boundingRect(contours[i])   
        cv2.rectangle(image, (x,y), (x+w,y+h), (153,153,0), 5) 
    

    (3)切割轮廓

    轮廓的切割主要是通过数组切片实现的,不过这里有一个小技巧:就是图片切割的w,h是宽和高,而数组讲的是行(row)和列(column) 所以,在切割图片时,数组的高和宽是反过来写的

      newimage=image[y+2:y+h-2,x+2:x+w-2] # 先用y确定高,再用x确定宽
                nrootdir=("E:/cut_image/")
                if not os.path.isdir(nrootdir):
                    os.makedirs(nrootdir)
                cv2.imwrite( nrootdir+str(i)+".jpg",newimage) 
                print (i)
    

    1.2 PIL Image图像处理库

    利用 PIL 中的函数,我们可以从大多数图像格式的文件中读取数据,然后写入最常见的图像格式文件中。PIL 中最重要的模块为 Image。要读取一幅图像,可以使用:

    from PIL import Image
    
    pil_im = Image.open('empire.jpg')
    

    图像的颜色转换可以使用 convert() 方法来实现。要读取一幅图像,并将其转换成灰度图像,只需要加上 convert('L'),如下所示:

    pil_im = Image.open('empire.jpg').convert('L')
    

    图片调整尺寸和旋转:

    要调整一幅图像的尺寸,我们可以调用 resize() 方法。该方法的参数是一个元组,用来指定新图像的大小:

    out = pil_im.resize((128,128))
    

    要旋转一幅图像,可以使用逆时针方式表示旋转角度,然后调用 rotate() 方法:

    out = pil_im.rotate(45)
    

    图片进行二值化处理:

    'L’表示灰度,'1’表示二值图模式。

    转换过程的关键在于设计映射表,如果只是需要一个简单的箝位值,可以将table中高于或低于箝位值的元素分别设为1与0。当然,由于这里的table并没有什么特殊要求,所以可以通过对元素的特殊设定实现(0, 255)范围内,任意需要的一对一映射关系。

    import Image
    
    # load a color image
    im = Image.open('fun.jpg')
    
    # convert to grey level image
    Lim = im.convert('L')
    Lim.save('fun_Level.jpg')
    
    # setup a converting table with constant threshold
    threshold = 80
    table = []
    for i in range(256):
        if i < threshold:
            table.append(0)
        else:
            table.append(1)
    
    # convert to binary image by the table
    bim = Lim.point(table, '1')
    
    bim.save('fun_binary.jpg')
    

    图片如下图所示:

    “fun.jpg”:
    在这里插入图片描述

    “fun_Level.jpg”:
    在这里插入图片描述

    “fun_binary.jpg”:
    在这里插入图片描述

    Image库显示图片:

    file_name='/home/cris/AI/MNIST/image/finaly.png'#导入自己的图片地址
    im = Image.open(file_name).convert('L')
     #将图片进行剪裁成28*28像素大小
    img = im.resize((28, 28), Image.ANTIALIAS).filter(ImageFilter.SHARPEN)
    #显示图片
    img.show()
    

    Image库剪裁图片:

    rom PIL import Image
    
    img = Image.open('1.jpg') # 打开当前路径图像
    
    box1 = (14, 4, 53, 52) # 设置图像裁剪区域 (x左上,y左上,x右下,y右下)
    
    image1 = img.crop(box1) # 图像裁剪
    
    image1.save('image1.jpg') # 存储裁剪得到的图像
    
    展开全文
  • 图像处理 图像分析和图像理解

    万次阅读 多人点赞 2018-06-11 00:17:06
    图像处理:利用计算机对图像进行去除噪声、增强、复原、分割、特征提取、识别、等处理的理论、方法和技术。狭义的图像处理主要是对图像进行各种加工,以改变图像的视觉效果并为自动识别奠定基础,或对图像进行压缩...



    图像处理:利用计算机对图像进行去除噪声、增强、复原、分割、特征提取、识别、等处理的理论、方法和技术。狭义的图像处理主要是对图像进行各种加工,以改变图像的视觉效果并为自动识别奠定基础,或对图像进行压缩编码以减少所需存储空间。

    图像分析:对图像中感兴趣的目标进行检测和测量,以获得他们的客观信息,从而建立对图像的描述。

    图像理解:重点是在图像分析的基础上,进一步研究图像中各目标的性质和它们之间的相互联系,并得出对图像内容含义的理解以及对原来客观场景的解释,从而指导和规划行动。

    三者之间的联系:图像处理是比较低层的操作,它主要在图像像素级上进行处理,处理的数据量非常大。图像分析则进入了中层,分割和特征提取把原来以像素描述的图像转变成比较简洁的非图形式的描述。图像理解主要是高层操作,基本上式对从描述抽象出来的符号进行运算,其处理过程和方法与人类的思维推理有许多类似之处。

    展开全文
  • matlab经常被用来处理图像,图像稍微大一点,经常会出现半天出不了结果的情况,对于一些新手来说,喜欢使用for循环对图像中每个像素进行处理,这是造成运行速度慢的主要原因之一,因此,总结几个可以避免使用for循环...

    matlab经常被用来处理图像,图像稍微大一点,经常会出现半天出不了结果的情况,对于一些新手来说,喜欢使用for循环对图像中每个像素进行处理,这是造成运行速度慢的主要原因之一,因此,总结几个可以避免使用for循环的函数:

    (1)find函数,find函数返回矩阵元素所在的位置,位置是从第一列开始,从上到下,1,2,3,...,,然后是第二列,第三列

    经常在图像中使用 如下: fseg(find(fsegmentgray<50& fsegmentgray>10))=1;利用一个矩阵对相同位置的另一个矩阵的元素作出判断或者赋值,可以避免使用循环;

    (2)reshape函数,reshape函数重新调整举证的行数、列数、维数。

    B = reshape(A,m,n)
    返回一个m*n的矩阵B, B中元素是按列从A中得到的。如果A中元素个数没有m*n个, 则会引发错误。
    a=[1 2 3;4 5 6;7 8 9;10 11 12];
           b=reshape(a,1,12);
           b =  1     4     7    10     2     5     8    11     3     6     9    12;
    比如在图像处理中经常要将图像所有像素作为一列进行处理,直接使用newimage=reshape(image,m*n,1),m和n为原始图像的行列值。这样就可以不用循环一个个做了。
    (3)sub2ind函数,ind2sub和sub2ind这对函数,是互逆的一对函数。ind2sub把数组或者矩阵的线性索引转化为相应的下标;sub2ind则正好相反,将下标转化为线性索引。这里的下标就是行列值,第几行第几列,线性索引就是按列开始算第几个。



    展开全文
  • 本文价值与收获 看完本文后,您将能够作出下面的界面 Jietu20200521-214922@2x.jpg ...Core Image核心图像是一种图像处理和分析技术,旨在为静止和视频图像提供近乎实时的处理。它使用 GPU...
  • MATLAB--数字图像处理 图像锐化(纯代码篇)

    万次阅读 多人点赞 2019-09-19 17:41:27
    图像锐化(image sharpening)是补偿图像的轮廓,增强图像的边缘及灰度跳变的部分,使图像变得清晰,分为空间域处理和频域处理两类。图像锐化是为了突出图像上地物的边缘、轮廓,或某些线性目标要素的特征。这种滤波...
  • 笔者小白在神经网络训练好然后进行手写数字的图片预测的时候碰到了这样的问题。利用python如何读取、保存、二值化、灰度化图片呢?如何利用opencv来处理图片呢?
  • MATLAB中log算子处理图像

    千次阅读 2018-11-22 08:37:01
    下面来介绍一下MATLAB中如何用log算子处理图像: 1、打开MATLAB软件,在其主界面中写入下列代码: I=imread('G:\MATLAB\bm.bmp'); %读取当前路径下的图片 subplot(2,2,1); imshow(I); title('原始图像'); I1=rgb2...
  • 基于TensorFlow批量的随机处理图片,实现图像增强

    千次阅读 热门讨论 2018-06-18 13:26:54
    TensorFlow它当中自带图像处理的接口。使我们能够很轻松的完成这些任务。你也可以在我的代码基础上。加上一些其他的图像处理的功能。比其他的图像处理的库要稍微简单一点。 """author:youngkun data:20180618 ...
  • 用于处理图像的库 golang

    千次阅读 2020-02-18 22:34:01
    Images ...用于处理图像的库。 bild- Collection of image processing algorithms in pure Go. 纯Go中图像处理算法的集合。 bimg- Small package for fast and efficient image processing u...
  • MATLAB--数字图像处理 图像锐化

    千次阅读 多人点赞 2019-12-12 22:40:32
    3.于MATLAB环境下编程实现对图片锐化。 三、实验内容     利用图像基于单方向梯度算子,Robert算子,Sobel算 子,Pritt算 子, Laplacian算子,多方向模板,LoG算子编写matlab增强程序;最后,...
  • 基本上有两个方法:一个是将你的图像统一进行一次重命名如:1.jpg,2.jpg等,然后利用for循环依次进行处理即可,如下面的语句:假设你的图像共有20副: str='D:\做差\好的图像\'; %我的图像放在D盘,做差文件夹下...
  • 数字图像处理 图像减法

    千次阅读 2019-02-19 17:04:13
    import numpy as np import cv2 def convert(r, h): s = r - h if np.min(s) &gt;= 0 and np.max(s) &lt;= 255: return s s = s - np.full(s.shape, np.min(s)) s = s * 255 / np.max(s) ...
  • OpenCV——读取摄像头并处理图像

    万次阅读 2018-04-23 18:48:28
    1、读取摄像头并处理图像的代码如下:#include&lt;opencv2/opencv.hpp&gt; using namespace cv; //-----------------------------------【main()函数】-------------------------------------------- //...
  • 为了加快处理速度,在图像处理算法中,往往需要把彩色图像转换为灰度图像。 0x00. 灰度图 灰度数字图像是每个像素只有一个采样颜色的图像,这类图像通常显示为从最暗黑色到最亮的白色的灰度。 灰度图像与...
  • python处理图像转化为uint8格式

    千次阅读 2019-11-17 10:18:15
    在python图像处理过程中,遇到的RGB图像的值是处于0-255之间的,为了更好的处理图像,通常会将图像值转变到0-1之间 这个处理的过程就是图像的uint8类型转变为float类型过程。img.astype('uint8')/255 float类型取值...
  • 数字图像处理 图像转换成文字(bmp2txt)0.引言我最近在大B站看到很多的字符动画,让我想起了我初一的时候也做过这东西.(真让人怀恋啊,现在都大三了) 现在我想让大家了解了解,这个东西的算法是什么样的(思路上基本上...
  • 基于MATLAB的卷积运算处理图像

    千次阅读 2015-10-29 21:21:00
    处理图像最外圈 适用于3*3的模板 孤点噪声平滑处理结果对比图: MATLAB代码: function [ B ] = mban( A ) %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % by Saniac 2015.10.29 % 使用3*3模板...
  • MATLAB--数字图像处理 图像平移

    万次阅读 多人点赞 2019-09-07 16:08:37
    图像平移 对于图像的平移,MATLAB中是可以利用膨胀函数平移图像。 代码: I = imread('a1.jpg'); se = translate(strel(1), [50 140]);%将一个平面结构化元素分别向下和向右移动30个位置 J = imdilate(I,se);%利用...
  • 图像处理-用Python3 处理图像像素

    千次阅读 2018-10-28 22:23:21
    python中利用numpy库和scipy库来进行各种数据操作和科学计算。...以后,只要是在python中进行数字图像处理,我们都需要导入这些包: from PIL import Image import numpy as np import matplotlib.pyplot as...
  •  在图像锐化增强中,我们希望找到一种各向同性的边缘检测算子,这个算子就是拉普拉斯算子,该算子及其对f(x,y)的作用是 由一维信号的锐化公式可得到二维数字图像的锐化公式为 (1) 在数字图像处理中, 和可用...
  • python——PIL Image处理图像

    千次阅读 2018-10-05 20:07:53
    1.使用PIL的Image处理图像时,需要导入包: from PIL import Image 2.图片读取: img = Image.open(&amp;amp;quot;D:\\test\\img\\test01.jpg&amp;amp;quot;) 或者: filename = &amp;amp;quot;D:\...
  • 想用android手机的摄像头扫描不断提取图像,对图像进行处理,若处理完成则退出,无法处理则继续通过摄像头提取图像处理。 请问应该通过什么方法达到这种效果? 多谢多谢!
  • MATLAB--数字图像处理 图像旋转

    千次阅读 2019-09-08 10:59:25
    图像旋转 图像的旋转其实矩阵的旋转,而整个矩阵的旋转,则可以看出单个坐标的旋转。也就是说,只有我们知道了单个坐标旋转后的坐标,那么就很好得出旋转之后的图像了。这里我们假定旋转后的图像大小不变哈。 对于看...
  • matlab灰度化、二值化处理图像

    万次阅读 多人点赞 2018-12-04 20:59:36
    matlab文字识别与提取: 1.图像转换为数字矩阵 ...rgb2gray :通过消除图像色调和饱和度信息同时保留亮度实现将将RGB图像或彩色图转换为灰度图像,即灰度化处理的功能 gdata = rgb2gray(data); ...
  • MATLAB--数字图像处理 图像直方图均衡化

    万次阅读 多人点赞 2019-09-03 15:43:01
    图像直方图均衡化 首先,我们要理解什么是图像直方图均衡化: 把原始图像的灰度直方图从比较集中的某个灰度区间变成在全部灰度范围内的均匀分布。直方图均衡化就是对图像进行非线性拉伸,重新分配图像像素值,使一定...
  • 在博客AlexNet原理及tensorflow实现训练神经网络的时候,做了数据增强,对图片处理采用的是PIL(Python Image Library), PIL是Python常用的图像处理库. 下面对PIL中常用到的操作进行整理: 1. 改变图片的大小 ...
  • MATLAB--数字图像处理 图像锐化(原理篇)

    千次阅读 多人点赞 2019-09-24 20:16:54
    图像锐化处理的目的是为了使图像的边缘、轮廓线以及图像的细节变得清晰,经过平滑的图像变得模糊的根本原因是因为图像受到了平均或积分运算,因此可以对其进行逆运算(如微分运算,其实这里用的是差分)就可以使图像变...
  • Java实现高斯模糊算法处理图像

    万次阅读 热门讨论 2015-12-21 21:53:11
    高斯模糊(英语:Gaussian Blur),也叫高斯平滑,是在Adobe Photoshop、GIMP以及Paint.NET等图像处理软件中广泛使用的处理效果,通常用它来减少图像噪声以及降低细节层次。 简介高斯模糊(Gaussian Blur)是美国...
  • Numpy处理图片方法

    千次阅读 2020-01-18 08:26:20
    在进行图像领域的深度学习的时候经常需要对图片进行处理,包括图像的翻转,压缩,截取等,一般都是用Numpy来处理处理起来也很方便。 In[3] # 导入需要的包 import numpy as np import matplotlib.pyplot as ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,686,382
精华内容 674,552
关键字:

如何处理图像