2016-02-24 21:04:01 jly58fgjk 阅读数 2915

学习了数字图像图像处理一段时间,下面是我对预处理方面的一些总结。

首先,了解了预处理对数字图像有什么影响?

预处理的主要目的是消除图像中无关的信息,恢复有用的真实信息,增强有关信息的可检测性和最大限度地简化数据,从而改进特征抽取、图像分割、匹配和识别的可靠性。预处理过程一般有数字化、几何变换、归一化、平滑、复原和增强等步骤。下面是我对图像增强的总结。

图像增强有很多种方法,针对不同图像要采取不同的方法,直方图均衡化、对比度拉伸是常用到的方法,使灰度图像颜色更加分明,针对含有噪声的图像。可以采用滤波,包含平滑滤波和锐化滤波。

一、直方图处理

1、直方图均衡化

直方图均衡化就是一种能仅靠输入图像直方图信息自动达到这种效果的变换函数。

它的基本思想是对图像中像素个数多的灰度级进行展宽,而对图像中像素个数少的灰度进行压缩,从而扩展像原取值的动态范围,提高了对比度和灰度色调的变化,使图像更加清晰。直方图均衡化是一种对图像的非线性拉伸,重新分配图像像素值,使一定灰度范围内的像素数量大致相同。直方图均衡化就是把给定图像的直方图分布改变成“均匀”分布直方图分布。

       函数:histeq

实现代码如下:I=imread('2.jpg');
                               I=rgb2gray(I);
                             %K=16; 
                            %H=histeq(I,K); 
                            H=histeq(I);

                    figure,,imshow(H); 

2、对比度拉伸   

函数:imadjust

代码例如:

I=imadjust(I2,stretchlim(I2),[0,1]);

二、滤波法

均值滤波

均值滤波是典型的线性滤波算法,它是指在图像上对目标像素给一个模板,该模板包括了其周围的临近像素(以目标象素为中心的周围8个像素,构成一个滤波模板,即去掉目标像素本身),再用模板中的全体像素的平均值来代替原来像素值。

模板有3*3、5*5、7*7三种。

实现代码如下:

clc;clear;close all;
img=rgb2gray(imread('lena1.jpg'));
figure;imshow(img);  
img_noise=double(imnoise(img,'gaussian',0.006));%添加高斯噪声 
figure,imshow(img_noise,[]); 
img_mean=imfilter(img_noise,fspecial('average',3)); %均值模板3*3
figure;imshow(img_mean,[]);title('de-noise by mean filter');
imag_mean=exp(imfilter(log(img_noise),fspecial('average',5)));%模板5*5 
figure;imshow(img_mean,[]),title('de-noise by mean filter');
Q=-1.5;  
img_mean=imfilter(img_noise.^(Q+1),fspecial('average',3))./imfilter(img_noise.^Q,fspecial('average',3)); 
figure;imshow(img_mean,[]);title('de-noise by mean filter'); 
Q=1.5;  img_mean=imfilter(img_noise.^(Q+1),fspecial('average',3))./imfilter(img_noise.^Q,fspecial('average',3)); 
figure;imshow(img_mean,[]);title('de-noise by mean filter');

中值滤波

中值滤波的基本原理是把数字图像或数字序列中一点的值用该点的一个邻域中各点值的中值代替,让周围的像素值接近的真实值,从而消除孤立的噪声点。方法是用某种结构的二维滑动模板,将板内像素按照像素值的大小进行排序,生成单调上升(或下降)的为二维数据序列。二维中值滤波输出为g(x,y)=med{f(x-k,y-l),(k,l∈W)} ,其中,f(x,y),g(x,y)分别为原始图像和处理后图像。W为二维模板,通常为3*3,5*5区域,也可以是不同的的形状,如线状,圆形,十字形,圆环形等。

实现代码如下:

img_median=medfilt2(img_noise);%中值滤波 
      figure;imshow(img_median,[]);title('de-noise by median filter')%中值滤波结果; 
     img_median2=medfilt2(img_midian); 
     figure;imshow(img_median2,[]);title('de-noise by median filter');

上述两种为平滑滤波

锐化滤波

  锐化用于补偿和增加图像的高频成分,使图像中的地物边界、区域边缘、线条、纹理特征和精细结构特征等更加清晰、鲜明。

利用算子prewitt、sobert、拉普拉斯算子实现

clc;clear;close all;
I=imread('lena.jpg');
%I=rgb2gray(I); 
subplot(221),imshow(I); title('原图');
hs=fspecial('sobel');
S=imfilter(I,hs);
hp=fspecial('prewitt'); 
P=imfilter(I,hs); 
A=double(I);%双精度型  
H=[0 1 0,1 -4 1,0 1 0];%拉普拉斯算子 
J=conv2(I,H,'same'); 
K=I-J;  
subplot(222),imshow(J); title('拉普拉斯锐化图像');
subplot(223),imshow(S); title('sobel算子锐化图像');
subplot(224),imshow(P); title('prewitt算子锐化图像');


低通滤波(平滑)

下面为巴特沃斯低通滤波的实现代码:

clc;clear;close all;
I=imread('lena1.jpg');
I=rgb2gray(I);
figure,imshow(I);
I1=fftshift(fft2(I));
[M,N]=size(I1);
n=2;d0=30;
n1=floor(M/2);
n2=floor(N/2);
for i=1:M
    for j=1:N
        d=sqrt((i-n1)^2+(j-n2)^2);
        H=1/(1+(d/d0)^(2*n));
        I2(i,j)=H*I1(i,j);
    end
end
I2=ifftshift(I2);
I3=real(ifft2(I2));
figure,imshow(I3,[]);

高通滤波(锐化)

下面代码为巴特沃斯高通滤波的实现代码:

clc;clear;close all;
f1=imread('lena1.jpg');
f1=rgb2gray(f1);
F= double(f1);     % 数据类型转换,MATLAB不支持图像的无符号整型的计算  
G = fft2(F);        % 傅立叶变换   
G = fftshift(G);     % 转换数据矩阵  
[M,N]=size(G);    
nn = 2;           % 二阶巴特沃斯(Butterworth)高通滤波器  
d0 = 5;  
m = fix(M/2);  
n = fix(N/2);  
for i = 1 : M       
    for j = 1 : N     
        d = sqrt((i-m)^2+(j-n)^2);   
        if (d == 0)      
             h = 0;   
        else
            h=1/(1+0.414*(d0/d)^(2*nn));% 计算传递函数   
        end;      
        result(i,j) = h * G(i,j);     
    end;  
end; 
result = ifftshift(result);   
J2= ifft2(result); 
J3= uint8(real(J2));
subplot(121);imshow(f1); title('灰色图像'); 
subplot(122);imshow(J3);  % 滤波后图像显示
title('滤波后的图像');

高斯滤波

部分代码:

%gaussian低通滤波
H=fspecial('gaussian',7,3);
F{2}=double(filter2(H,I));
figure,imshow(F{2},[]);


滤波部分实现代码网址

http://wenku.baidu.com/link?url=3U5MZxgxbursdIBYSVden1i8rxSxFlBaf_glnibz8Me2hG6vADZz5419XQIRlc5OrpGM8uibQI_siBwoiFvaDVPM1ewwgRV48voh7sgIoIi

http://wenku.baidu.com/link?url=esi3wmkrucc4k3lbHFtSGL2OWFMjZwz_hoB_aQQh6GiXDwxni9GFnMGhJVOWgBa6Ulm3Vf1qB0auBjKRyCY_EBKPpgMZphXeovcTRG1WyHK


 

2019-12-18 20:22:46 weixin_44222014 阅读数 231

1. 引言

在深度学习中,为了丰富图像数据的训练集,更好的提取图像特征,泛化模型(防止模型过拟合),一般都会对图像数据进行数据增强(Data Augmentation)。

2. 数据增强

在深度学习中,为了避免出现过拟合(Overfitting),通常我们需要输入充足的数据量。若数据量比较小,可以对原有的图像数据进行几何变换,改变图像像素的位置并保证特征不变。

数据增强,一般常用的方式有旋转图像,剪切图像,改变图像色差,扭曲图像特征,改变图像尺寸大小,增强图像噪音(一般使用高斯噪音,椒盐噪音)等。但是需要注意,尽量不要加入其他图像轮廓的噪音。

  • 旋转 | 反射变换(Rotation/reflection): 随机旋转图像一定角度; 改变图像内容的朝向;
  • 翻转变换(flip): 沿着水平或者垂直方向翻转图像;
  • 缩放变换(zoom): 按照一定的比例放大或者缩小图像;
  • 平移变换(shift): 在图像平面上对图像以一定方式进行平移;
    可以采用随机或人为定义的方式指定平移范围和平移步长, 沿水平或竖直方向进行平移. 改变图像内容的位置;
  • 尺度变换(scale): 对图像按照指定的尺度因子, 进行放大或缩小; 或者参照SIFT特征提取思想, 利用指定的尺度因子对图像滤波构造尺度空间. 改变图像内容的大小或模糊程度;
  • 对比度变换(contrast): 在图像的HSV颜色空间,改变饱和度S和V亮度分量,保持色调H不变. 对每个像素的S和V分量进行指数运算(指数因子在0.25到4之间), 增加光照变化;
  • 噪声扰动(noise): 对图像的每个像素RGB进行随机扰动, 常用的噪声模式是椒盐噪声和高斯噪声;
  • 颜色变换(color): 在训练集像素值的RGB颜色空间进行PCA, 得到RGB空间的3个主方向向量,3个特征值, p1, p2, p3, λ1, λ2, λ3.

3. 数据增强方法代码示例

# -*- coding:utf-8 -*-
"""数据增强
   1. 翻转变换 flip
   2. 随机修剪 random crop
   3. 色彩抖动 color jittering
   4. 平移变换 shift
   5. 尺度变换 scale
   6. 对比度变换 contrast
   7. 噪声扰动 noise
   8. 旋转变换/反射变换 Rotation/reflection
   author: XiJun.Gong
   date:2016-11-29
"""
 
from PIL import Image, ImageEnhance, ImageOps, ImageFile
import numpy as np
import random
import threading, os, time
import logging
import cv2
logger = logging.getLogger(__name__)
ImageFile.LOAD_TRUNCATED_IMAGES = True
 
 
class DataAugmentation:
    """
    包含数据增强的八种方式
    """
 
 
    def __init__(self):
        pass
 
    @staticmethod
    def openImage(image):
        return Image.open(image, mode="r")
 
    @staticmethod
    def randomRotation(image, mode=Image.BICUBIC):
        """
         对图像进行随机任意角度(0~360度)旋转
        :param mode 邻近插值,双线性插值,双三次B样条插值(default)
        :param image PIL的图像image
        :return: 旋转转之后的图像
        """
        random_angle = np.random.randint(1, 360)
        return image.rotate(random_angle, mode)
        #return image.rotate(180, mode)
 
    @staticmethod
    def randomFlip(image):
        #图像翻转(类似于镜像,镜子中的自己)
        #FLIP_LEFT_RIGHT,左右翻转
        #FLIP_TOP_BOTTOM,上下翻转
        #ROTATE_90, ROTATE_180, or ROTATE_270.按照角度进行旋转,与randomRotate()功能类似
        return image.transpose(Image.FLIP_LEFT_RIGHT)
   
    @staticmethod
    def Tranform(image):
        #t图像变换
        #im.transform(size, method, data) ⇒ image
 
        #im.transform(size, method, data, filter) ⇒ image
        #1:image.transform((300,300), Image.EXTENT, (0, 0, 300, 300)) 
        #   变量data为指定输入图像中两个坐标点的4元组(x0,y0,x1,y1)。
        #   输出图像为这两个坐标点之间像素的采样结果。
        #   例如,如果输入图像的(x0,y0)为输出图像的(0,0)点,(x1,y1)则与变量size一样。
        #   这个方法可以用于在当前图像中裁剪,放大,缩小或者镜像一个任意的长方形。
        #   它比方法crop()稍慢,但是与resize操作一样快。
        #2:image.transform((300,300), Image.AFFINE, (1, 2,3, 2, 1,4))
        #   变量data是一个6元组(a,b,c,d,e,f),包含一个仿射变换矩阵的第一个两行。
        #   输出图像中的每一个像素(x,y),新值由输入图像的位置(ax+by+c, dx+ey+f)的像素产生,
        #   使用最接近的像素进行近似。这个方法用于原始图像的缩放、转换、旋转和裁剪。
        #3: image.transform((300,300), Image.QUAD, (0,0,0,500,600,500,600,0))
        #   变量data是一个8元组(x0,y0,x1,y1,x2,y2,x3,y3),它包括源四边形的左上,左下,右下和右上四个角。
        #4: image.transform((300,300), Image.MESH, ())
        #   与QUAD类似,但是变量data是目标长方形和对应源四边形的list。
        #5: image.transform((300,300), Image.PERSPECTIVE, (1,2,3,2,1,6,1,2))
        #   变量data是一个8元组(a,b,c,d,e,f,g,h),包括一个透视变换的系数。
        #   对于输出图像中的每个像素点,新的值来自于输入图像的位置的(a x + b y + c)/(g x + h y + 1),
        #   (d x+ e y + f)/(g x + h y + 1)像素,使用最接近的像素进行近似。
        #   这个方法用于原始图像的2D透视。
        return image.transform((300,300), Image.EXTENT, (0, 0, 300, 300))
 
    @staticmethod
    def randomCrop(image):
        """
        对图像随意剪切,考虑到图像大小范围(68,68),使用一个一个大于(36*36)的窗口进行截图
        :param image: PIL的图像image
        :return: 剪切之后的图像
        """
        image_width = image.size[0]
        image_height = image.size[1]
        crop_win_size = np.random.randint(40, 68)
        random_region = (
            (image_width - crop_win_size) >> 1, (image_height - crop_win_size) >> 1, (image_width + crop_win_size) >> 1,
            (image_height + crop_win_size) >> 1)
        return image.crop(random_region)
 
    @staticmethod
    def randomColor(image):
        """
        对图像进行颜色抖动
        :param image: PIL的图像image
        :return: 有颜色色差的图像image
        """
        random_factor = np.random.randint(0, 31) / 10.  # 随机因子
        color_image = ImageEnhance.Color(image).enhance(random_factor)  # 调整图像的饱和度
        random_factor = np.random.randint(10, 21) / 10.  # 随机因子
        brightness_image = ImageEnhance.Brightness(color_image).enhance(random_factor)  # 调整图像的亮度
        random_factor = np.random.randint(10, 21) / 10.  # 随机因1子
        contrast_image = ImageEnhance.Contrast(brightness_image).enhance(random_factor)  # 调整图像对比度
        random_factor = np.random.randint(0, 31) / 10.  # 随机因子
        return ImageEnhance.Sharpness(contrast_image).enhance(random_factor)  # 调整图像锐度
 
    @staticmethod
    def randomGaussian(image, mean=0.2, sigma=0.3):
        """
         对图像进行高斯噪声处理
        :param image:
        :return:
        """
 
        def gaussianNoisy(im, mean=0.2, sigma=0.3):
            """
            对图像做高斯噪音处理
            :param im: 单通道图像
            :param mean: 偏移量
            :param sigma: 标准差
            :return:
            """
            for _i in range(len(im)):
                im[_i] += random.gauss(mean, sigma)
            return im
 
        # 将图像转化成数组
        img = np.asarray(image)
        img.flags.writeable = True  # 将数组改为读写模式
        width, height = img.shape[:2]
        img_r = gaussianNoisy(img[:, :, 0].flatten(), mean, sigma)
        img_g = gaussianNoisy(img[:, :, 1].flatten(), mean, sigma)
        img_b = gaussianNoisy(img[:, :, 2].flatten(), mean, sigma)
        img[:, :, 0] = img_r.reshape([width, height])
        img[:, :, 1] = img_g.reshape([width, height])
        img[:, :, 2] = img_b.reshape([width, height])
        return Image.fromarray(np.uint8(img))
 
    @staticmethod
    def saveImage(image, path):
        image.save(path)
 
 
def makeDir(path):
    try:
        if not os.path.exists(path):
            if not os.path.isfile(path):
                # os.mkdir(path)
                os.makedirs(path)
            return 0
        else:
            return 1
    except Exception, e:
        print str(e)
        return -2
 
 
def imageOps(func_name, image, des_path, file_name, times=5):
    #funcMap = {"randomRotation": DataAugmentation.randomRotation,
    #           "randomCrop": DataAugmentation.randomCrop,
    #           "randomColor": DataAugmentation.randomColor,
    #           "randomGaussian": DataAugmentation.randomGaussian
    #           "randomFlip":DataAugmentation.randomFlip,
    #           }
    funcMap = {
               "Tranform":DataAugmentation.Tranform
               }
    if funcMap.get(func_name) is None:
        logger.error("%s is not exist", func_name)
        return -1
 
    for _i in range(0, times, 1):
        new_image = funcMap[func_name](image)
        DataAugmentation.saveImage(new_image, os.path.join(des_path, func_name + str(_i) + file_name))
 
 
#opsList = {"randomFlip","randomRotation", "randomCrop", "randomColor", "randomGaussian"}
opsList = { "Tranform"}
 
def threadOPS(path, new_path):
    """
    多线程处理事务
    :param src_path: 资源文件
    :param des_path: 目的地文件
    :return:
    """
    if os.path.isdir(path):
        img_names = os.listdir(path)
    else:
        img_names = [path]
    for img_name in img_names:
        print img_name
        tmp_img_name = os.path.join(path, img_name)
        if os.path.isdir(tmp_img_name):
            if makeDir(os.path.join(new_path, img_name)) != -1:
                threadOPS(tmp_img_name, os.path.join(new_path, img_name))
            else:
                print 'create new dir failure'
                return -1
                # os.removedirs(tmp_img_name)
        elif tmp_img_name.split('.')[1] != "DS_Store":
            # 读取文件并进行操作
            image = DataAugmentation.openImage(tmp_img_name)
            threadImage = [0] * 5
            _index = 0
            for ops_name in opsList:
                threadImage[_index] = threading.Thread(target=imageOps,
                                                       args=(ops_name, image, new_path, img_name,))
                threadImage[_index].start()
                _index += 1
                time.sleep(0.2)
 
 
if __name__ == '__main__':
    threadOPS("D:\datasets\dataArgument\JPEGImages",
              "D:\datasets\dataArgument\Dealed_JPEGImages")
2018-09-26 17:55:40 qq_35358021 阅读数 1576

图像数据增强

介绍2种图像增强的方法

导入需要的模块

import random
import cv2

介绍2种使用的比较多的方法:旋转和翻转

def random_rotate_img(img, min_angle, max_angle):
    '''
        random rotation an image

    :param img:         image to be rotated
    :param min_angle:   min angle to rotate
    :param max_angle:   max angle to rotate
    :return:            image after random rotated
    '''
    if not isinstance(img, list):
        img = [img]

    angle = random.randint(min_angle, max_angle)
    center = (img[0].shape[0] / 2, img[0].shape[1] / 2)
    rot_matrix = cv2.getRotationMatrix2D(center, angle, scale=1.0)

    res = []
    for img_inst in img:
        img_inst = cv2.warpAffine(img_inst, rot_matrix, dsize=img_inst.shape[:2], borderMode=cv2.BORDER_CONSTANT)
        res.append(img_inst)
    if len(res) == 0:
        res = res[0]
    return res


def random_flip_img(img):
    '''
        random flip image,both on horizontal and vertical

    :param img:                 image to be flipped

    :return:                    image after flipped
    '''
    flip_val = 0
    if not isinstance(img, list):
        res = cv2.flip(img, flip_val)  # 0 = X axis, 1 = Y axis,  -1 = both
    else:
        res = []
        for img_item in img:
            img_flip = cv2.flip(img_item, flip_val)
            res.append(img_flip)
    return res

把旋转和反转后的图像进行保存

if __name__ == '__main__':
    imagePath = './data/chaper3_img_01.png'
    # 读取dicom文件的元数据(dicom tags)
    img = cv2.imread(imagePath, cv2.IMREAD_GRAYSCALE)
    print(img.shape)
    res_rotate = random_rotate_img(img, 30, 90)
    cv2.imwrite('./temp_dir/chapter3_rotate_img.png', res_rotate[0])
    res_flip = random_flip_img(img)
    cv2.imwrite('./temp_dir/chapter3_flip_img.png', res_flip)
2019-12-11 15:14:32 weixin_43991027 阅读数 23

python图像数据增强

图像数据增强库
参考博客:https://www.cnblogs.com/vincentcheng/p/9186540.html

介绍两个图像增强库:Augmentor和imgaug,Augmentor使用比较简单,只有一些简单的操作。 imgaug实现的功能更多,可以对keypoint, bounding box同步处理,比如你现在由一些标记好的数据,只有同时对原始图片和标记信息同步处理,才能有更多的标记数据进行训练。我在segmentation和detection任务经常使用imgaug这个库。

Augmentor:

https://augmentor.readthedocs.io/en/master/index.html

Augmentor是管道化的图像增强库,每一个操作都是逐步叠加到图像上的。另外,对输入的图像可以选择按照一定概率进行增强,如随机对一般的图像进行增强。

rotate(probability=0.5, max_left_rotation=5, max_right_rotation=10)

可以实现的操作有, rotate, crop, perspective skew(视角倾斜), elastic distortions(弹性变换), sheering(坐标轴倾斜), mirroring(镜像)
可以使用Augumentor.Pipeline()创建一个实例,调用各种方法向pipeline添加方法, status()可以显示当前pipeline的状态,在status中每个操作都有一个对应的index, remove_operation(index)移除一个操作, 最后调用sample(nums)得到nums个augument后的图像。

import Augmentor
p = Augmentor.Pipeline("/path/to/images/")
p.status()
p.remove_operation(0
  1. rotate
    rotate() 旋转,非90度旋转会带来padding或者裁剪
    rotate90()
    rotate180()
    rotate270()
    rotate_random_90() 随机旋转,90, 180, 270
  2. resize
    crop
    crop_centre()
    crop_by_size()
    crop_random()
  3. sheer
    sheer()
  4. mirroring
    flip_left_right()
    flip_top_bottom()
    flip_random()
  5. elastic distortion
    random_distortion() Before
    在这里插入图片描述
    在这里插入图片描述
    变换是在计算机视觉任务中经常使用的一种变换,比较有名的Segmentation Model U-Net就使用了elastic deformation来对自己的数据做Augmentation.最后取得了较好的效果.

imgaug

http://imgaug.readthedocs.io/en/latest/index.html

  1. Keypoint
    在这里插入图片描述
  2. Bounding Boxes
    这个部分做object detection的人应该经常用到。
    imgaug支持:
    -----将bounding boxes作为对象表示
    -----增强boundiing boxes
    -----在图像上画bounding boxes
    -----boxing boxes移动, 映射, 计算IoU
    在这里插入图片描述

imgaug详细解释:
https://blog.csdn.net/limiyudianzi/article/details/86497305

2019-08-23 13:07:29 weixin_44877480 阅读数 372

机器学习随笔-记录自己的学习之路

简介:图像数据增强通常有以下几种方式:图像水平翻转、垂直翻转、平移、旋转、亮度调整、加噪声。本文利用opencv和numpy实现了以上数据增强方法,代码如下

  • 水平翻转
def horizon_flip(img):
    '''
    图像水平翻转
    :param img:
    :return:水平翻转后的图像
    '''
    return img[:, ::-1]
  • 垂直翻转
def vertical_flip(img):
    '''
    图像垂直翻转
    :param img:
    :return:
    '''
    return img[::-1]
  • 旋转
    利用cv2.getRotationMatrix2D获取旋转矩阵(坐标变换),和下图所学的旋转坐标变换矩阵不太一样,因为下图的旋转坐标计算公式是按同一坐标点旋转坐标系计算,但是旋转图像最后是要同统一一个图像坐标系,即图像左上角为原点建立坐标系。
    在这里插入图片描述
    在这里插入图片描述
def rotate(img, limit_up=10, limit_down=-10):
    '''
    在一定角度范围内,图像随机旋转
    :param img:
    :param limit_up:旋转角度上限
    :param limit_down: 旋转角度下限
    :return: 旋转后的图像
    '''
    # 旋转矩阵
    rows, cols = img.shape[:2]
    center_coordinate = (int(cols / 2), int(rows / 2))
    angle = random.uniform(limit_down, limit_up)
    M = cv2.getRotationMatrix2D(center_coordinate, angle, 1)
    # 仿射变换
    out_size = (cols, rows)
    rotate_img = cv2.warpAffine(img, M, out_size, borderMode=cv2.BORDER_REPLICATE)
    return rotate_img
  • 平移
    需要自己设置坐标变换矩阵
    在这里插入图片描述
def shift(img, distance_down, distance_up):
    '''
    利用仿射变换实现图像平移,平移距离∈[down, up]
    :param img: 原图
    :param distance_down:移动距离下限
    :param distance_up: 移动距离上限
    :return: 平移后的图像
    '''
    rows, cols = img.shape[:2]
    y_shift = random.uniform(distance_down, distance_up)
    x_shift = random.uniform(distance_down, distance_up)
    # 生成平移矩阵
    M = np.float32([[1, 0, x_shift], [0, 1, y_shift]])
    # 平移
    img_shift = cv2.warpAffine(img, M, (cols, rows), borderMode=cv2.BORDER_REPLICATE)
    return img_shift
  • 裁剪
def crop(img, crop_x, crop_y):
    '''
    读取部分图像,进行裁剪
    :param img:
    :param crop_x:裁剪x尺寸
    :param crop_y:裁剪y尺寸
    :return:
    '''
    rows, cols = img.shape[:2]
    # 偏移像素点
    x_offset = random.randint(0, cols - crop_x)
    y_offset = random.randint(0, rows - crop_y)
    # 读取部分图像
    img_part = img[y_offset:(y_offset+crop_y), x_offset:(x_offset+crop_x)]
    return img_part
  • 对比度、亮度调整
    图像像素点灰度值调整公式:x’ = k * x + b,k是对比度系数,b是亮度增加
def lighting_adjust(img, k_down, k_up, b_down, b_up):
    '''
    图像亮度、对比度调整
    :param img:
    :param k_down:对比度系数下限
    :param k_up:对比度系数上限
    :param b_down:亮度增值上限
    :param b_up:亮度增值下限
    :return:调整后的图像
    '''
    # 对比度调整系数
    slope = random.uniform(k_down, k_up)
    # 亮度调整系数
    bias = random.uniform(b_down, b_up)
    # 图像亮度和对比度调整
    img = img * slope + bias
    # 灰度值截断,防止超出255
    img = np.clip(img, 0, 255)
    return img.astype(np.uint8)
  • 高斯噪声
def Gaussian_noise(img, mean=0, std=1):
    '''
    图像加高斯噪声
    :param img: 原图
    :param mean: 均值
    :param std: 标准差
    :return:
    '''
    # 高斯噪声图像
    gauss = np.random.normal(loc=mean, scale=std, size=img.shape)
    img_gauss = img + gauss
    # 裁剪
    out = np.clip(img_gauss, 0, 255)
    return out
  • 归一化
def normalization(img, mean, std):
    '''
    图像归一化,图像像素点从(0,255)->(0,1)
    :param img:
    :param mean:所有样本图像均值
    :param std: 所有样本图像标准差
    :return:
    '''
    img -= mean
    img /= std
    
	return img

-------------------------------------------------------手动分割线--------------------------------------------------------------
备注:如对文章有任何疑问或者建议请在评论下方留言。同时欢迎对计算机视觉、深度学习感兴趣的同学找我交流

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