예제 #1
0
def save(org, binary, corners_block, corners_img, corners_compo, compos_class,
         corners_text):
    # *** Step 7 *** post-processing: remove img elements from original image and segment into smaller size
    # draw results
    draw_bounding = draw.draw_bounding_box_class(org, corners_compo,
                                                 compos_class)
    draw_bounding = draw.draw_bounding_box_class(
        draw_bounding, corners_block,
        ['block' for i in range(len(corners_block))])
    draw_bounding = draw.draw_bounding_box_class(
        draw_bounding, corners_img, ['img' for i in range(len(corners_img))])
    draw_bounding = draw.draw_bounding_box(draw_bounding, corners_text, line=1)
    # save results
    binary_r = pre.reverse_binary(binary)
    cv2.imwrite('output/org.png', org)
    cv2.imwrite('output/gradient_r.png', binary_r)
    cv2.imwrite('output/gradient.png', binary)
    cv2.imwrite('output/labeled.png', draw_bounding)
    file.save_corners_json('output/compo.json', corners_block,
                           ['div' for i in range(len(corners_block))])
    file.save_corners_json('output/compo.json', corners_img,
                           ['div' for i in range(len(corners_img))])
    file.save_corners_json('output/compo.json', corners_compo, compos_class)

    if is_clip:
        file.save_clipping(org, 'output/components', corners_compo,
                           compos_class, {})
def save(org, binary, corners_block, corners_img, corners_compo, compos_class,
         output_path_label, output_path_img_drawn, output_path_img_bin):
    # *** Step 7 *** post-processing: remove img elements from original image and segment into smaller size
    # draw results
    draw_bounding = draw.draw_bounding_box_class(org, corners_compo,
                                                 compos_class)
    draw_bounding = draw.draw_bounding_box_class(
        draw_bounding, corners_block,
        ['block' for i in range(len(corners_block))])
    draw_bounding = draw.draw_bounding_box_class(
        draw_bounding, corners_img, ['img' for i in range(len(corners_img))])
    # save results
    binary_r = pre.reverse_binary(binary)
    cv2.imwrite('data/output/org.png', org)
    cv2.imwrite('data/output/gradient_r.png', binary_r)
    cv2.imwrite(output_path_img_bin, binary)
    cv2.imwrite(output_path_img_drawn, draw_bounding)
    file.save_corners_json(output_path_label,
                           corners_compo,
                           compos_class,
                           new=True)
    file.save_corners_json(output_path_label,
                           corners_block,
                           ['block' for i in range(len(corners_block))],
                           new=False)
    file.save_corners_json(output_path_label,
                           corners_img,
                           ['img' for i in range(len(corners_img))],
                           new=False)
def compo_in_img(processing, org, binary, corners_img, corners_block,
                 corners_compo, compos_class):
    """
    Detect potential UI components inner img;
    Only leave non-img
    """
    corners_img_new = []
    pad = 2
    for corner in corners_img:
        (top_left, bottom_right) = corner
        (col_min, row_min) = top_left
        (col_max, row_max) = bottom_right
        col_min = max(col_min - pad, 0)
        col_max = min(col_max + pad, org.shape[1])
        row_min = max(row_min - pad, 0)
        row_max = min(row_max + pad, org.shape[0])
        height_img = row_max - row_min
        width_img = col_max - col_min

        img_area = height_img * width_img
        compo_area = 0

        # ignore small ones
        # if height_img <= min_compo_edge_length or width_img <= min_compo_edge_length:
        #     continue

        clip_org = org[row_min:row_max, col_min:col_max]
        clip_bin = binary[row_min:row_max, col_min:col_max]
        clip_bin = pre.reverse_binary(clip_bin)

        corners_block_new, corners_compo_new, compos_class_new = processing(
            clip_org, clip_bin, main=False)
        corners_block_new = util.corner_cvt_relative_position(
            corners_block_new, col_min, row_min)
        corners_compo_new = util.corner_cvt_relative_position(
            corners_compo_new, col_min, row_min)

        assert len(corners_compo_new) == len(compos_class_new)

        # ignore blocks superposed on its parent img
        for b in corners_block_new:
            (col_min_new, row_min_new), (col_max_new, row_max_new) = b
            height_new = row_max_new - row_min_new
            width_new = col_max_new - col_min_new
            if height_new / height_img < 0.9 and width_new / width_img < 0.9:
                corners_block.append(corners_block_new)
                compo_area += height_new * width_new

        # only leave non-img elements
        for i in range(len(corners_compo_new)):
            if compos_class_new[i] != 'img':
                # ignore compos superposed on its parent img
                (col_min_new,
                 row_min_new), (col_max_new,
                                row_max_new) = corners_compo_new[i]
                height_new = row_max_new - row_min_new
                width_new = col_max_new - col_min_new

                corners_compo.append(corners_compo_new[i])
                compos_class.append(compos_class_new[i])
                compo_area += height_new * width_new

        # ignore imgs full of components
        if compo_area / img_area < 0.5:
            corners_img_new.append(corner)

    corners_compo, compos_class = merge_corner(corners_compo, compos_class)
    corners_img = rm_img_in_compo(corners_img_new, corners_compo)

    return corners_block, corners_img, corners_compo, compos_class