python图像特征提取进行分割,区域生长图像分割算法python

  python图像特征提取进行分割,区域生长图像分割算法python

  图像分割就是把图像分成若干个特定的、具有独特性质的区域并提出感兴趣目标的技术和过程。本文将为大家分享两个用大蟒实现像分割增强的方法,需要的可以参考一下

  方法一

  随机导入

  将数组作为铭牌导入

  从太平航运导入图像、图像操作、图像过滤器

  从撇除.过滤器导入高斯

  进口火炬

  导入数学

  导入号码

  随机导入

  类RandomVerticalFlip(对象):

  def __call__(self,img):

  if random.random() 0.5:

  return img.transpose(图片。翻转_顶部_底部)

  返回图片

  类反规范化(对象):

  def __init__(自身,均值,标准差):

  自我平均=平均

  self.std=std

  def __call__(self,tensor):

  对于活力中的t,m,s(张量,自均值,自标准差):

  t.mul_ .add_(m)

  返回张量

  掩蔽传感器类(对象):

  def __call__(self,img):

  返回火炬。from _ numpy(NP。array(img,dtype=np.int32)).long()

  类别飞思卡尔(对象):

  def __init__(自身,大小,插值=图片.双线性):

  自我。size=tuple(反转(大小))# size :(高,宽)

  自插值=插值

  def __call__(self,img):

  return img.resize(self.size,self.interpolation)

  班级挂图(对象):

  def __call__(self,img):

  img=np.array(img)[:-1]

  返回形象。从数组(img。astype(NP。uint 8))

  类RandomGaussianBlur(对象):

  def __call__(self,img):

  西格玛=0.15 random.random() * 1.15

  模糊_img=高斯(np.array(img),sigma=sigma,多通道=真)

  模糊_img *=255

  返回图像。from数组(fubled _ img。astype(NP。uint 8))

  # 组合

  类构成(对象):

  def __init__(自身,转换):

  自我转换=转换

  def __call__(自身,img,面具):

  assert img.size==mask.size

  用于t in self.transforms:

  img,掩码=t(img,掩码)

  返回图像,遮罩

  # 随机裁剪

  类随机作物(对象):

  def __init__(self,size,padding=0):

  如果是实例(大小,数字。编号):

  self.size=(int(size),int(size))

  else:

  self.size=size

  自填充=填充

  def __call__(自身,img,面具):

  如果自填充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图像分割增强内容请搜索盛行IT软件开发工作室以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT软件开发工作室!

郑重声明:本文由网友发布,不代表盛行IT的观点,版权归原作者所有,仅为传播更多信息之目的,如有侵权请联系,我们将第一时间修改或删除,多谢。

留言与评论(共有 条评论)
   
验证码: