详解Python实现图像分割增强的两种方法

2024-04-02 19:04:59 854人浏览独家记忆

Python 官方文档：入门教程 => 点击学习

摘要

方法一 import random import numpy as np from PIL import Image, ImageOps, ImageFilter from skim

方法一

import random
import numpy as np
from PIL import Image, ImageOps, ImageFilter
from skimage.filters import gaussian
import torch
import math
import numbers
import random

class RandomVerticalFlip(object):
    def __call__(self, img):
        if random.random() < 0.5:
            return img.transpose(Image.FLIP_TOP_BOTTOM)
        return img

class DeNORMalize(object):
    def __init__(self, mean, std):
        self.mean = mean
        self.std = std

    def __call__(self, tensor):
        for t, m, s in zip(tensor, self.mean, self.std):
            t.mul_(s).add_(m)
        return tensor

class MaskToTensor(object):
    def __call__(self, img):
        return torch.from_numpy(np.array(img, dtype=np.int32)).long()

class FreeScale(object):
    def __init__(self, size, interpolation=Image.BILINEAR):
        self.size = tuple(reversed(size))  # size: (h, w)
        self.interpolation = interpolation

    def __call__(self, img):
        return img.resize(self.size, self.interpolation)

class FlipChannels(object):
    def __call__(self, img):
        img = np.array(img)[:, :, ::-1]
        return Image.fromarray(img.astype(np.uint8))

class RandomGaussianBlur(object):
    def __call__(self, img):
        sigma = 0.15 + random.random() * 1.15
        blurred_img = gaussian(np.array(img), sigma=sigma, multichannel=True)
        blurred_img *= 255
        return Image.fromarray(blurred_img.astype(np.uint8))
# 组合
class Compose(object):
    def __init__(self, transforms):
        self.transforms = transforms

    def __call__(self, img, mask):
        assert img.size == mask.size
        for t in self.transforms:
            img, mask = t(img, mask)
        return img, mask
# 随机裁剪
class RandomCrop(object):
    def __init__(self, size, padding=0):
        if isinstance(size, numbers.Number):
            self.size = (int(size), int(size))
        else:
            self.size = size
        self.padding = padding

    def __call__(self, img, mask):
        if self.padding > 0:
            img = ImageOps.expand(img, border=self.padding, fill=0)
            mask = ImageOps.expand(mask, border=self.padding, fill=0)

        assert img.size == mask.size
        w, h = img.size
        th, tw = self.size
        if w == tw and h == th:
            return img, mask
        if w < tw or h < th:
            return img.resize((tw, th), Image.BILINEAR), mask.resize((tw, th), Image.NEAREST)

        x1 = random.randint(0, w - tw)
        y1 = random.randint(0, h - th)
        return img.crop((x1, y1, x1 + tw, y1 + th)), mask.crop((x1, y1, x1 + tw, y1 + th))

#  中心裁剪
class CenterCrop(object):
    def __init__(self, size):
        if isinstance(size, numbers.Number):
            self.size = (int(size), int(size))
        else:
            self.size = size

    def __call__(self, img, mask):
        assert img.size == mask.size
        w, h = img.size
        th, tw = self.size
        x1 = int(round((w - tw) / 2.))
        y1 = int(round((h - th) / 2.))
        return img.crop((x1, y1, x1 + tw, y1 + th)), mask.crop((x1, y1, x1 + tw, y1 + th))


class RandomHorizontallyFlip(object):
    def __call__(self, img, mask):
        if random.random() < 0.5:
            return img.transpose(Image.FLIP_LEFT_RIGHT), mask.transpose(Image.FLIP_LEFT_RIGHT)
        return img, mask

class Scale(object):
    def __init__(self, size):
        self.size = size

    def __call__(self, img, mask):
        assert img.size == mask.size
        w, h = img.size
        if (w >= h and w == self.size) or (h >= w and h == self.size):
            return img, mask
        if w > h:
            ow = self.size
            oh = int(self.size * h / w)
            return img.resize((ow, oh), Image.BILINEAR), mask.resize((ow, oh), Image.NEAREST)
        else:
            oh = self.size
            ow = int(self.size * w / h)
            return img.resize((ow, oh), Image.BILINEAR), mask.resize((ow, oh), Image.NEAREST)

class RandomSizedCrop(object):
    def __init__(self, size):
        self.size = size

    def __call__(self, img, mask):
        assert img.size == mask.size
        for attempt in range(10):
            area = img.size[0] * img.size[1]
            target_area = random.uniform(0.45, 1.0) * area
            aspect_ratio = random.uniform(0.5, 2)

            w = int(round(math.sqrt(target_area * aspect_ratio)))
            h = int(round(math.sqrt(target_area / aspect_ratio)))

            if random.random() < 0.5:
                w, h = h, w

            if w <= img.size[0] and h <= img.size[1]:
                x1 = random.randint(0, img.size[0] - w)
                y1 = random.randint(0, img.size[1] - h)

                img = img.crop((x1, y1, x1 + w, y1 + h))
                mask = mask.crop((x1, y1, x1 + w, y1 + h))
                assert (img.size == (w, h))

                return img.resize((self.size, self.size), Image.BILINEAR), mask.resize((self.size, self.size),
                                                                                       Image.NEAREST)

        # Fallback
        scale = Scale(self.size)
        crop = CenterCrop(self.size)
        return crop(*scale(img, mask))

class RandomRotate(object):
    def __init__(self, degree):
        self.degree = degree

    def __call__(self, img, mask):
        rotate_degree = random.random() * 2 * self.degree - self.degree
        return img.rotate(rotate_degree, Image.BILINEAR), mask.rotate(rotate_degree, Image.NEAREST)

class RandomSized(object):
    def __init__(self, size):
        self.size = size
        self.scale = Scale(self.size)
        self.crop = RandomCrop(self.size)

    def __call__(self, img, mask):
        assert img.size == mask.size

        w = int(random.uniform(0.5, 2) * img.size[0])
        h = int(random.uniform(0.5, 2) * img.size[1])

        img, mask = img.resize((w, h), Image.BILINEAR), mask.resize((w, h), Image.NEAREST)

        return self.crop(*self.scale(img, mask))

class SlidinGCropOld(object):
    def __init__(self, crop_size, stride_rate, ignore_label):
        self.crop_size = crop_size
        self.stride_rate = stride_rate
        self.ignore_label = ignore_label

    def _pad(self, img, mask):
        h, w = img.shape[: 2]
        pad_h = max(self.crop_size - h, 0)
        pad_w = max(self.crop_size - w, 0)
        img = np.pad(img, ((0, pad_h), (0, pad_w), (0, 0)), 'constant')
        mask = np.pad(mask, ((0, pad_h), (0, pad_w)), 'constant', constant_values=self.ignore_label)
        return img, mask

    def __call__(self, img, mask):
        assert img.size == mask.size

        w, h = img.size
        long_size = max(h, w)

        img = np.array(img)
        mask = np.array(mask)

        if long_size > self.crop_size:
            stride = int(math.ceil(self.crop_size * self.stride_rate))
            h_step_num = int(math.ceil((h - self.crop_size) / float(stride))) + 1
            w_step_num = int(math.ceil((w - self.crop_size) / float(stride))) + 1
            img_sublist, mask_sublist = [], []
            for yy in range(h_step_num):
                for xx in range(w_step_num):
                    sy, sx = yy * stride, xx * stride
                    ey, ex = sy + self.crop_size, sx + self.crop_size
                    img_sub = img[sy: ey, sx: ex, :]
                    mask_sub = mask[sy: ey, sx: ex]
                    img_sub, mask_sub = self._pad(img_sub, mask_sub)
                    img_sublist.append(Image.fromarray(img_sub.astype(np.uint8)).convert('RGB'))
                    mask_sublist.append(Image.fromarray(mask_sub.astype(np.uint8)).convert('P'))
            return img_sublist, mask_sublist
        else:
            img, mask = self._pad(img, mask)
            img = Image.fromarray(img.astype(np.uint8)).convert('RGB')
            mask = Image.fromarray(mask.astype(np.uint8)).convert('P')
            return img, mask


class SlidingCrop(object):
    def __init__(self, crop_size, stride_rate, ignore_label):
        self.crop_size = crop_size
        self.stride_rate = stride_rate
        self.ignore_label = ignore_label

    def _pad(self, img, mask):
        h, w = img.shape[: 2]
        pad_h = max(self.crop_size - h, 0)
        pad_w = max(self.crop_size - w, 0)
        img = np.pad(img, ((0, pad_h), (0, pad_w), (0, 0)), 'constant')
        mask = np.pad(mask, ((0, pad_h), (0, pad_w)), 'constant', constant_values=self.ignore_label)
        return img, mask, h, w

    def __call__(self, img, mask):
        assert img.size == mask.size

        w, h = img.size
        long_size = max(h, w)

        img = np.array(img)
        mask = np.array(mask)

        if long_size > self.crop_size:
            stride = int(math.ceil(self.crop_size * self.stride_rate))
            h_step_num = int(math.ceil((h - self.crop_size) / float(stride))) + 1
            w_step_num = int(math.ceil((w - self.crop_size) / float(stride))) + 1
            img_slices, mask_slices, slices_info = [], [], []
            for yy in range(h_step_num):
                for xx in range(w_step_num):
                    sy, sx = yy * stride, xx * stride
                    ey, ex = sy + self.crop_size, sx + self.crop_size
                    img_sub = img[sy: ey, sx: ex, :]
                    mask_sub = mask[sy: ey, sx: ex]
                    img_sub, mask_sub, sub_h, sub_w = self._pad(img_sub, mask_sub)
                    img_slices.append(Image.fromarray(img_sub.astype(np.uint8)).convert('RGB'))
                    mask_slices.append(Image.fromarray(mask_sub.astype(np.uint8)).convert('P'))
                    slices_info.append([sy, ey, sx, ex, sub_h, sub_w])
            return img_slices, mask_slices, slices_info
        else:
            img, mask, sub_h, sub_w = self._pad(img, mask)
            img = Image.fromarray(img.astype(np.uint8)).convert('RGB')
            mask = Image.fromarray(mask.astype(np.uint8)).convert('P')
            return [img], [mask], [[0, sub_h, 0, sub_w, sub_h, sub_w]]

方法二

import numpy as np
import random

import torch
from torchvision import transforms as T
from torchvision.transforms import functional as F


def pad_if_smaller(img, size, fill=0):
    # 如果图像最小边长小于给定size，则用数值fill进行padding
    min_size = min(img.size)
    if min_size < size:
        ow, oh = img.size
        padh = size - oh if oh < size else 0
        padw = size - ow if ow < size else 0
        img = F.pad(img, (0, 0, padw, padh), fill=fill)
    return img


class Compose(object):
    def __init__(self, transforms):
        self.transforms = transforms

    def __call__(self, image, target):
        for t in self.transforms:
            image, target = t(image, target)
        return image, target


class RandomResize(object):
    def __init__(self, min_size, max_size=None):
        self.min_size = min_size
        if max_size is None:
            max_size = min_size
        self.max_size = max_size

    def __call__(self, image, target):
        size = random.randint(self.min_size, self.max_size)
        # 这里size传入的是int类型，所以是将图像的最小边长缩放到size大小
        image = F.resize(image, size)
        # 这里的interpolation注意下，在torchvision(0.9.0)以后才有InterpolationMode.NEAREST
        # 如果是之前的版本需要使用PIL.Image.NEAREST
        target = F.resize(target, size, interpolation=T.InterpolationMode.NEAREST)
        return image, target


class RandomHorizontalFlip(object):
    def __init__(self, flip_prob):
        self.flip_prob = flip_prob

    def __call__(self, image, target):
        if random.random() < self.flip_prob:
            image = F.hflip(image)
            target = F.hflip(target)
        return image, target


class RandomCrop(object):
    def __init__(self, size):
        self.size = size

    def __call__(self, image, target):
        image = pad_if_smaller(image, self.size)
        target = pad_if_smaller(target, self.size, fill=255)
        crop_params = T.RandomCrop.get_params(image, (self.size, self.size))
        image = F.crop(image, *crop_params)
        target = F.crop(target, *crop_params)
        return image, target


class CenterCrop(object):
    def __init__(self, size):
        self.size = size

    def __call__(self, image, target):
        image = F.center_crop(image, self.size)
        target = F.center_crop(target, self.size)
        return image, target


class ToTensor(object):
    def __call__(self, image, target):
        image = F.to_tensor(image)
        target = torch.as_tensor(np.array(target), dtype=torch.int64)
        return image, target


class Normalize(object):
    def __init__(self, mean, std):
        self.mean = mean
        self.std = std

    def __call__(self, image, target):
        image = F.normalize(image, mean=self.mean, std=self.std)
        return image, target

到此这篇关于详解python实现图像分割增强的两种方法的文章就介绍到这了,更多相关Python图像分割增强内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: 详解Python实现图像分割增强的两种方法

本文链接: https://www.lsjlt.com/news/141087.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

详解Python实现图像分割增强的两种方法

方法一 import random import numpy as np from PIL import Image, ImageOps, ImageFilter from skim...

99+

2022-11-13
Python OpenCV实现图像增强操作详解

目录创作背景图像亮度增强和降低旋转水平镜像和垂直镜像高斯噪声其它图像增强的方法创作背景最近在忙着两个YOLOv7项目，通过看大量的论文，发现很多的相关的论文都会在收集图像后进行图像...

99+

2022-11-11
详解PythonOpenCV图像分割算法的实现

目录前言1.图像二值化2.自适应阈值分割算法3.Otsu阈值分割算法4.基于轮廓的字符分离4.1轮廓检测 4.2轮廓绘制4.3包围框获取4.4矩形绘制前言图像...

99+

2022-11-11
python+opencv图像分割实现分割不规则ROI区域方法汇总

在图像分割领域，一个重要任务便是分割出感兴趣（ROI）区域。如果是简易的矩形ROI区域其实是非常容易分割的，opencv的官方python教程里也有教到最简易的矩形ROI分割（剪裁）...

99+

2022-11-12
Python基于域相关实现图像增强的方法教程

目录介绍昆虫增强使用针的增强实验结果介绍当在图像上训练深度神经网络模型时，通过对由数据增强生成的更多图像进行训练，可以使模型更好地泛化。常用的增强包括水平和垂直翻转/移位、以一定角...

99+

2022-11-12
Python+OpenCV实现阈值分割的方法详解

目录一、全局阈值1.效果图2.源码二、滑动改变阈值(滑动条)1.效果图2.源码三、自适应阈值分割1.效果图2.源码3.GaussianBlur()函数去噪四、参数解释一、全局阈值原...

99+

2022-11-11
Python基于域相关实现图像增强的方法是什么

这篇文章主要讲解了“Python基于域相关实现图像增强的方法是什么”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“Python基于域相关实现图像增强的方法是什么”吧！介绍当在图像上训练深度神经...

99+

2023-06-26
Python基于纹理背景和聚类算法实现图像分割详解

目录一.基于纹理背景的图像分割二.基于K-Means聚类算法的区域分割三.总结一.基于纹理背景的图像分割该部分主要讲解基于图像纹理信息（颜色）、边界信息（反差）和背景信息的图像分割...

99+

2023-01-03

Python 纹理图像分割 Python 聚类算法图像分割 Python图像分割
python实现selenium截图的两种方法

目录pyvirtualdisplayXvfb可以使用虚拟屏幕的方式，在虚拟屏幕上运行浏览器并进行截图操作，这样就不会影响当前屏幕的展示。具体实现可以使用Xvfb和pyvirtual...

99+

2023-05-14

python selenium截图 selenium截图
Python实现图像手绘效果的方法详解

目录图像的数组表示图像的RGB色彩模式PIL库图像组成图像的变换图像的手绘效果手绘效果展示代码展示与讲解图像的数组表示图像的RGB色彩模式图像一般使用RGB色彩模式，即每个像素...

99+

2022-11-11
OpenCV-Python使用分水岭算法实现图像的分割与提取

目录图像分割分水岭算法waterShed函数形态学分割distanceTransform函数确定未知区域ConnectedComponents函数实战分水岭算法随着当今世界的发展，计...

99+

2022-11-12
python实现单例的两种方法解读

目录python 实现单例的方法第一种方法：使用基类第二种方法：使用装饰器python 单例对象单列模式总结python 实现单例的方法第一种方法：使用基类 New 是真正创建实例...

99+

2023-03-02

python实现单例 python单例 python单例方法
Java实现Excel转PDF的两种方法详解

目录一、使用spire转化PDF1、使用spire将整个Excel文件转为PDF2、指定单个的sheet页转为PDF二、使用jacob实现Excel转PDF（推荐使用）1、环境准备2...

99+

2022-11-13
C语言中栈的两种实现方法详解

目录一、顺序栈二、链式栈总结一、顺序栈 #include<stdio.h> #include<stdlib.h> #define maxsize 64 ...

99+

2022-11-12
python实现读取并显示图片的两种方法

在 python 中除了用 opencv，也可以用 matplotlib 和 PIL 这两个库操作图片。本人偏爱 matpoltlib，因为它的语法更像 matlab。一、matplotlib 1. 显示...

99+

2022-06-04

两种方法图片
前端实现打印功能的两种方法详解

目录前言方法一：window.print() 方法二：利用iframe,iframe.contentWindow.print()补充：导出步骤总结：前言前端...

99+

2023-01-06

前端实现打印功能前端打印语句前端打印功能实现
Python 三种方法实现截图【详解+完整代码】

人生苦短我用python 如何用python实现截屏？一、方法一 PIL中的ImageGrab模块使用PIL中的ImageGrab模块简单，但是效率有点低 PIL是Python Imaging...

99+

2023-09-03

python 开发语言 opencv pycharm
Python实现在图像中隐藏二维码的方法详解

目录一、前言二、隐写三、位平面分解3.1 图像3.2 位平面3.3 位平面分解3.4 位平面合成四、图像隐写一、前言在某个App中有一个加密水印的功能，当帖子的主人开启了之后。如果...

99+

2022-11-11
Java实现大文件的分割与合并的方法详解

目录一、题目描述-合并多个文本文件1、题目2、解题思路3、代码详解二、题目描述-对大文件进行分割处理1、题目2、解题思路3、代码详解三、题目描述-分割后又再次合并1、题目2、解题思路...

99+

2022-11-13

Java文件分割 Java文件合并 Java 文件分割合并
Python实现二值掩膜影像去噪与边缘强化方法详解

目录前言一、方法二、代码三、效果测试前言这篇博客主要解决的一个问题是掩膜图像的噪声去除和边缘强化，如下图1所示。可以看到掩膜图像上有很多的斑点噪声，而且掩膜的轮廓也不够清晰。所以我...

99+

2023-01-28

Python二值掩膜影像去噪 Python边缘强化