[
    {
        "label": 1,
        "transcription": "ILIO'S",
        "points": [
            [
                372.0,
                242.0
            ],
            [
                479.0,
                242.0
            ],
            [
                479.0,
                178.0
            ],
            [
                372.0,
                178.0
            ]
        ]
    },
    ...
]

data['image'] = (img.astype('float32') * self.scale - self.mean) / self.std

def __call__(self, data):
    import json
    label = data['label']
    # 将标号的json字符串反序列化
    annotations = json.loads(label)
    boxes, texts, text_inds, labels, edges = [], [], [], [], []
    for ann in annotations:
        # 获取标号中边界框的坐标
        box = ann['points']
        # 提取四个坐标的X轴值
        x_list = [box[i][0] for i in range(4)]
        # 提取四个坐标的Y轴值
        y_list = [box[i][1] for i in range(4)]
        # 从左上角开始，顺时针排序各个坐标点
        sorted_x_list, sorted_y_list = self.sort_vertex(x_list, y_list)
        sorted_box = []
        # 重新将排序后X轴，Y轴数组转换为点的数组
        for x, y in zip(sorted_x_list, sorted_y_list):
            sorted_box.append(x)
            sorted_box.append(y)
        boxes.append(sorted_box)

      # 获取文字标号
      text = ann['transcription']
      texts.append(ann['transcription'])
      # 将文字转换为字典文件中的序号，例如WildReceipt数据集的字典中，j将会被转换为数字49
      text_ind = [self.dict[c] for c in text if c in self.dict]
      text_inds.append(text_ind)
      # 提取标号中的分类信息
      if 'label' in ann.keys():
          labels.append(ann['label'])
      elif 'key_cls' in ann.keys():
          labels.append(ann['key_cls'])
      else:
          raise ValueError("Cannot found 'key_cls' in ann.keys(), please check your training annotation.")
      # 提取标号中的edge信息，但实际WildReceipt数据集中并未提供该标号
      edges.append(ann.get('edge', 0))
  ann_infos = dict(
      image=data['image'],
      points=boxes,
      texts=texts,
      text_inds=text_inds,
      edges=edges,
      labels=labels)

  return self.list_to_numpy(ann_infos)

def list_to_numpy(self, ann_infos):
    """Convert bboxes, relations, texts and labels to ndarray."""
    boxes, text_inds = ann_infos['points'], ann_infos['text_inds']
    boxes = np.array(boxes, np.int32)
    # 计算边界框之间的关系
    relations, bboxes = self.compute_relation(boxes)

    labels = ann_infos.get('labels', None)
    if labels is not None:
        labels = np.array(labels, np.int32)
        edges = ann_infos.get('edges', None)
        if edges is not None:
            # 给labels添加一个新的维度，shape从[n]变为[n, 1]
            labels = labels[:, None]
            edges = np.array(edges)
            # 将edge从一维数组变为一个n*n的矩阵，每一行代表这条边的标号是否与其他边相同。对角线为1
            edges = (edges[:, None] == edges[None, :]).astype(np.int32)
            if self.directed:
                edges = (edges & labels == 1).astype(np.int32)
            np.fill_diagonal(edges, -1)
            # 将labels转换为列向量后和edges矩阵拼接，拼接后的形状为[n, n+1]
            labels = np.concatenate([labels, edges], -1)
    # 由于每个文字标号的长度都不一样，将每个文字标号的长度都调整为300，不足的用-1补齐。recoder_len是最长的文字长度。
    padded_text_inds, recoder_len = self.pad_text_indices(text_inds)
    max_num = 300
    # 初始化[300, 4]的矩阵存放边界框
    temp_bboxes = np.zeros([max_num, 4])
    h, _ = bboxes.shape
    # 将边界框填入上述的容器，不足的位置以0补齐
    temp_bboxes[:h, :] = bboxes

    # 初始化[300, 300, 5]的张量存放边界框之间的关系
    temp_relations = np.zeros([max_num, max_num, 5])
    # 填入关系
    temp_relations[:h, :h, :] = relations

    # 初始化[300, 300]的矩阵存放文字
    temp_padded_text_inds = np.zeros([max_num, max_num])
    # 填入文字
    temp_padded_text_inds[:h, :] = padded_text_inds

    # 初始化[300, 300]的矩阵存放标签(包括边信息)
    temp_labels = np.zeros([max_num, max_num])
    # 存入标签信息
    temp_labels[:h, :h + 1] = labels

    tag = np.array([h, recoder_len])
    return dict(
        image=ann_infos['image'],
        points=temp_bboxes,
        relations=temp_relations,
        texts=temp_padded_text_inds,
        labels=temp_labels,
        tag=tag)

def compute_relation(self, boxes):
    """Compute relation between every two boxes."""
    # 所有边界框左上角点的X,Y轴值, 形状都是[n, 1]
    x1s, y1s = boxes[:, 0:1], boxes[:, 1:2]
    # 所有边界框右下角点的X,Y轴值, 形状都是[n, 1]
    x2s, y2s = boxes[:, 4:5], boxes[:, 5:6]
    # ws是同一个框右下X减去左上X，即宽度。+1防止ws是0
    # hs是右下Y减去左上Y，但是最小值限制在1以上。
    # ws和hs的形状都是[n, 1]
    ws, hs = x2s - x1s + 1, np.maximum(y2s - y1s + 1, 1)
    # self.norm为常数10
    # x1s[:, 0][None]的形状是[1, n]减去x1s利用了广播机制，变为了[n, n]的矩阵，dxs代表了所有框两两之间X轴的距离。
    # 同样的，dys代表了Y轴上的记录，他们都除以了归一化常数10.
    dxs = (x1s[:, 0][None] - x1s) / self.norm
    dys = (y1s[:, 0][None] - y1s) / self.norm
    # 同样的， hs[:, 0][None] / hs利用广播机制形成了[n, n]的矩阵，xhhs代表了所有框两两之间的高度比
    # 而xwhs则代表两两之间的宽高比
    xhhs, xwhs = hs[:, 0][None] / hs, ws[:, 0][None] / hs
    # whs则代表了当前框自身的宽高比
    whs = ws / hs + np.zeros_like(xhhs)
    # 将上述五个特征按每两个边界框之间的关系放入一个数组，形成shape为[n, n, 5]的张量
    relations = np.stack([dxs, dys, whs, xhhs, xwhs], -1)
    # 将左上X,Y,右下X,Y作为一组向量代表一个边界框，形状为[n, 4]
    bboxes = np.concatenate([x1s, y1s, x2s, y2s], -1).astype(np.float32)
    return relations, bboxes

def forward(self, inputs):
    img = inputs[0]
    relations, texts, gt_bboxes, tag, img_size = inputs[1], inputs[
        2], inputs[3], inputs[5], inputs[-1]
    # 预处理，将各个变量转换为paddle.Tensor
    img, relations, texts, gt_bboxes = self.pre_process(
        img, relations, texts, gt_bboxes, tag, img_size)
    x = self.img_feat(img)
    boxes, rois_num = self.bbox2roi(gt_bboxes)
    # 对图片输出进行ROI Pooling
    feats = paddle.vision.ops.roi_align(
        x, boxes, spatial_scale=1.0, output_size=7, boxes_num=rois_num)
    feats = self.maxpool(feats).squeeze(-1).squeeze(-1)
    return [relations, texts, feats]

class UNet(nn.Layer):
    def __init__(self):
        super(UNet, self).__init__()
        self.down1 = Encoder(num_channels=3, num_filters=16)
        self.down2 = Encoder(num_channels=16, num_filters=32)
        self.down3 = Encoder(num_channels=32, num_filters=64)
        self.down4 = Encoder(num_channels=64, num_filters=128)
        self.down5 = Encoder(num_channels=128, num_filters=256)

        self.up1 = Decoder(32, 16)
        self.up2 = Decoder(64, 32)
        self.up3 = Decoder(128, 64)
        self.up4 = Decoder(256, 128)
        self.out_channels = 16

    def forward(self, inputs):
        x1, _ = self.down1(inputs)
        _, x2 = self.down2(x1)
        _, x3 = self.down3(x2)
        _, x4 = self.down4(x3)
        _, x5 = self.down5(x4)

        x = self.up4(x4, x5)
        x = self.up3(x3, x)
        x = self.up2(x2, x)
        x = self.up1(x1, x)
        return x

def bbox2roi(self, bbox_list):
    rois_list = []
    rois_num = []
    for img_id, bboxes in enumerate(bbox_list):
        # roi数量与实际的边界框数相同
        rois_num.append(bboxes.shape[0])
        # 每个roi与边界框一样大
        rois_list.append(bboxes)
    rois = paddle.concat(rois_list, 0)
    rois_num = paddle.to_tensor(rois_num, dtype='int32')
    return rois, rois_num

feats = paddle.vision.ops.roi_align(
    x, boxes, spatial_scale=1.0, output_size=7, boxes_num=rois_num)