一、mosaic

通过随机缩放、随机裁剪、随机排布的方式进行拼接，提升对小目标的检测效果。
image.png

1.1 主函数

  1. def __getitem__(self, index):
  2.     index = index % self.length
  4.     #---------------------------------------------------#
  5.     #   训练时进行数据的随机增强
  6.     #   推理时不进行数据的随机增强
  7.     #---------------------------------------------------#
  8.     if self.mosaic:
  9.         if self.rand() < 0.5 and self.epoch_now < self.epoch_length * self.mosaic_ratio:
  10.             #随机选取张图片的标签信息
  11.             lines = sample(self.annotation_lines, 3)
  12.             #将本次index的图片加入列表，总共四张图片进行mosaic
  13.             lines.append(self.annotation_lines[index])
  14.             #随机打乱顺序
  15.             shuffle(lines)
  16.             image, box  = self.get_random_data_with_Mosaic(lines, self.input_shape)
  17.         else:
  18.             image, box  = self.get_random_data(self.annotation_lines[index], self.input_shape, random = self.train)
  19.         else:
  20.             image, box      = self.get_random_data(self.annotation_lines[index], self.input_shape, random = self.train)
  21.             image       = np.transpose(preprocess_input(np.array(image, dtype=np.float32)), (2, 0, 1))
  22.             box         = np.array(box, dtype=np.float32)
  23.             if len(box) != 0:
  24.                 box[:, 2:4] = box[:, 2:4] - box[:, 0:2]
  25.                 box[:, 0:2] = box[:, 0:2] + box[:, 2:4] / 2
  26.         return image, box

1.2 get_random_data_with_Mosaic函数

输入：四张图片的标签信息，输入尺寸
输出：图像和真实框坐标

  1. image, box  = self.get_random_data_with_Mosaic(lines, self.input_shape)
  1. def get_random_data_with_Mosaic(self, annotation_line, input_shape, jitter=0.3, hue=.1, sat=0.7, val=0.4):
  2.     #640,640
  3.     h, w = input_shape
  4.     #随机选取最小偏置
  5.     min_offset_x = self.rand(0.3, 0.7)
  6.     min_offset_y = self.rand(0.3, 0.7)
  8.     image_datas = [] 
  9.     box_datas   = []
  10.     index       = 0
  11.     #选取一张图片的标签
  12.     for line in annotation_line:
  13.         #---------------------------------#
  14.         #   每一行进行分割
  15.         #    分割为两部分，第一部分为图片存储地址，第二部分为真实框坐标和类别
  16.         #---------------------------------#
  17.         line_content = line.split()
  18.         #---------------------------------#
  19.         #   打开图片
  20.         #---------------------------------#
  21.         image = Image.open(line_content[0])
  22.         image = cvtColor(image)
  24.         #---------------------------------#
  25.         #   图片的大小
  26.         #---------------------------------#
  27.         iw, ih = image.size
  28.         #---------------------------------#
  29.         #   保存框的位置和类别
  30.         #---------------------------------#
  31.         box = np.array([np.array(list(map(int,box.split(',')))) for box in line_content[1:]])
  33.         #---------------------------------#
  34.         #   是否翻转图片
  35.         #---------------------------------#
  36.         flip = self.rand()<.5
  37.         if flip and len(box)>0:
  38.             image = image.transpose(Image.FLIP_LEFT_RIGHT)
  39.             #左右翻转x坐标
  40.             box[:, [0,2]] = iw - box[:, [2,0]]
  42.         #------------------------------------------#
  43.         #   对图像进行缩放并且进行长和宽的扭曲
  44.         #------------------------------------------#
  45.         new_ar = iw/ih * self.rand(1-jitter,1+jitter) / self.rand(1-jitter,1+jitter)
  46.         scale = self.rand(.4, 1)
  47.         if new_ar < 1:
  48.             nh = int(scale*h)
  49.             nw = int(nh*new_ar)
  50.         else:
  51.             nw = int(scale*w)
  52.             nh = int(nw/new_ar)
  53.         image = image.resize((nw, nh), Image.BICUBIC)
  55.         #-----------------------------------------------#
  56.         #   将图片进行放置，分别对应四张分割图片的位置
  57.         #-----------------------------------------------#
  58.         if index == 0:
  59.             dx = int(w*min_offset_x) - nw
  60.             dy = int(h*min_offset_y) - nh
  61.         elif index == 1:
  62.             dx = int(w*min_offset_x) - nw
  63.             dy = int(h*min_offset_y)
  64.         elif index == 2:
  65.             dx = int(w*min_offset_x)
  66.             dy = int(h*min_offset_y)
  67.         elif index == 3:
  68.             dx = int(w*min_offset_x)
  69.             dy = int(h*min_offset_y) - nh
  71.         new_image = Image.new('RGB', (w,h), (128,128,128))
  72.         new_image.paste(image, (dx, dy))
  73.         image_data = np.array(new_image)
  75.         index = index + 1
  76.         box_data = []
  77.         #---------------------------------#
  78.         #   对box进行重新处理
  79.         #---------------------------------#
  80.         if len(box)>0:
  81.             np.random.shuffle(box)
  82.             box[:, [0,2]] = box[:, [0,2]]*nw/iw + dx
  83.             box[:, [1,3]] = box[:, [1,3]]*nh/ih + dy
  84.             #防止越界
  85.             box[:, 0:2][box[:, 0:2]<0] = 0
  86.             box[:, 2][box[:, 2]>w] = w
  87.             box[:, 3][box[:, 3]>h] = h
  88.             #计算宽高
  89.             box_w = box[:, 2] - box[:, 0]
  90.             box_h = box[:, 3] - box[:, 1]
  91.             box = box[np.logical_and(box_w>1, box_h>1)]
  92.             box_data = np.zeros((len(box),5))
  93.             box_data[:len(box)] = box
  95.         image_datas.append(image_data)
  96.         box_datas.append(box_data)
  98.     #---------------------------------#
  99.     #   将图片分割，放在一起
  100.     #---------------------------------#
  101.     cutx = int(w * min_offset_x)
  102.     cuty = int(h * min_offset_y)
  104.     new_image = np.zeros([h, w, 3])
  105.     new_image[:cuty, :cutx, :] = image_datas[0][:cuty, :cutx, :]
  106.     new_image[cuty:, :cutx, :] = image_datas[1][cuty:, :cutx, :]
  107.     new_image[cuty:, cutx:, :] = image_datas[2][cuty:, cutx:, :]
  108.     new_image[:cuty, cutx:, :] = image_datas[3][:cuty, cutx:, :]
  110.     new_image       = np.array(new_image, np.uint8)
  111.     #---------------------------------#
  112.     #   对图像进行色域变换
  113.     #   计算色域变换的参数
  114.     #---------------------------------#
  115.     r               = np.random.uniform(-1, 1, 3) * [hue, sat, val] + 1
  116.     #---------------------------------#
  117.     #   将图像转到HSV上
  118.     #---------------------------------#
  119.     hue, sat, val   = cv2.split(cv2.cvtColor(new_image, cv2.COLOR_RGB2HSV))
  120.     dtype           = new_image.dtype
  121.     #---------------------------------#
  122.     #   应用变换
  123.     #---------------------------------#
  124.     x       = np.arange(0, 256, dtype=r.dtype)
  125.     lut_hue = ((x * r[0]) % 180).astype(dtype)
  126.     lut_sat = np.clip(x * r[1], 0, 255).astype(dtype)
  127.     lut_val = np.clip(x * r[2], 0, 255).astype(dtype)
  129.     new_image = cv2.merge((cv2.LUT(hue, lut_hue), cv2.LUT(sat, lut_sat), cv2.LUT(val, lut_val)))
  130.     new_image = cv2.cvtColor(new_image, cv2.COLOR_HSV2RGB)
  132.     #---------------------------------#
  133.     #   对框进行进一步的处理
  134.     #---------------------------------#
  135.     new_boxes = self.merge_bboxes(box_datas, cutx, cuty)
  137.     return new_image, new_boxes