绘制COCO数据集结果

import os
import time
import datetime
import mmcv
import cv2 as cv
import json
import numpy as np
import pycocotools.mask as maskutil
import pycocotools.coco as COCO
from itertools import groupby
from skimage import measure,draw,data
from PIL import Image

def close_contour(contour):
    if not np.array_equal(contour[0], contour[-1]):
        contour = np.vstack((contour, contour[0]))
    return contour

def binary_mask_to_polygon(binary_mask, tolerance=0):
    """Converts a binary mask to COCO polygon representation
    Args:
        binary_mask: a 2D binary numpy array where '1's represent the object
        tolerance: Maximum distance from original points of polygon to approximated
            polygonal chain. If tolerance is 0, the original coordinate array is returned.
    """
    polygons = []
    # pad mask to close contours of shapes which start and end at an edge
    padded_binary_mask = np.pad(binary_mask, pad_width=1, mode='constant', constant_values=0)
    contours = measure.find_contours(padded_binary_mask, 0.5)
    contours = np.subtract(contours, 1)
    for contour in contours:
        contour = close_contour(contour)
        contour = measure.approximate_polygon(contour, tolerance)
        if len(contour) < 3:
            continue
        contour = np.flip(contour, axis=1)
        segmentation = contour.ravel().tolist()
        # after padding and subtracting 1 we may get -0.5 points in our segmentation
        segmentation = [0 if i < 0 else i for i in segmentation]
        polygons.append(segmentation)

    return polygons

def binary_mask_to_rle(binary_mask):
    rle = {'counts': [], 'size': list(binary_mask.shape)}
    counts = rle.get('counts')
    for i, (value, elements) in enumerate(groupby(binary_mask.ravel(order='F'))):
        if i == 0 and value == 1:
                counts.append(0)
        counts.append(len(list(elements)))
    return rle

def main2():
    seg=np.array([312.29, 562.89, 402.25, 511.49, 400.96, 425.38, 398.39, 372.69, 388.11, 332.85, 318.71, 325.14, 295.58, 305.86, 269.88, 314.86, 258.31, 337.99, 217.19, 321.29, 182.49, 343.13, 141.37, 348.27, 132.37, 358.55, 159.36, 377.83, 116.95, 421.53, 167.07, 499.92, 232.61, 560.32, 300.72, 571.89])
    compactedRLE = maskutil.frPyObjects([seg], 768, 768)
    print(compactedRLE)
    #compactedRLE=[
    # {"size":[768, 768],
    #     "counts": "`eQ66ig02O1O000000000000000000000000001O00000000000000000000000000000000000000000000000000000000O2O0NbZj:"
    #     }]
    mask = maskutil.decode(compactedRLE)
    mask=np.reshape(mask,(768,768))
    mask[:,:]=mask[:,:]*255
    print(mask)
    #mmcv.imshow(mask)

    '''
    mask=np.array(
        [
            [0, 0, 0, 0, 0, 0, 0, 0],
            [0, 0, 1, 1, 0, 0, 1, 0],
            [0, 0, 1, 1, 1, 1, 1, 0],
            [0, 0, 1, 1, 1, 1, 1, 0],
            [0, 0, 1, 1, 1, 1, 1, 0],
            [0, 0, 1, 0, 0, 0, 1, 0],
            [0, 0, 1, 0, 0, 0, 1, 0],
            [0, 0, 0, 0, 0, 0, 0, 0]
        ]
    )
    print(mask)
    '''

    poly=binary_mask_to_polygon(mask)
    print(poly)
    rle=binary_mask_to_rle(mask)
    print(rle)
    #mmcv.imshow(area)

    return 0

def class2color(classes=1,class_id=0):
    sum = classes*12357
    return [sum%(class_id+0),sum%(class_id+1),sum%(class_id+2)]

def mainContour():
    imgfile = "/home/wit/Pictures/7dd98d1001e9390100d9e95171ec54e737d19681.jpg"
    img = cv.imread(imgfile)
    h, w, _ = img.shape

    gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

    ret, thresh = cv.threshold(gray, 127, 255, cv.THRESH_BINARY)

    # Find Contour
    _, contours, hierarchy = cv.findContours(thresh, cv.RETR_TREE, cv.CHAIN_APPROX_NONE)
    print(contours)

def main():
    testimagepath   = "/media/wit/WeiJX/AirbusShip/coco-labels/instances_ships_test2018.json"
    compressedRLECOCOlabelpath = "/media/wit/WeiJX/workspace/out/maskrcnn.reorg.pkl.json"
    imageprefix     = "/media/wit/WeiJX/AirbusShip/test-images/"

    startTime = time.time()
    trthset = json.load(open(testimagepath, 'r'))
    assert type(trthset) == dict, 'annotation file format {} not supported'.format(type(trthset))
    prdcset = json.load(open(compressedRLECOCOlabelpath, 'r'))
    assert type(prdcset) == dict, 'annotation file format {} not supported'.format(type(prdcset))
    print('Done (t={:0.2f}s)'.format(time.time() - startTime))

    ann_Y0 = trthset['annotations']
    ann_Y1 = prdcset['annotations']

    for image in trthset['images']:
        imagepath = imageprefix+image['file_name']
        img = cv.imread(imagepath)

        src = np.zeros((768,768,3), np.uint8)
        src[:,:,:]=img[:,:,:]
        dst = np.zeros((768,768,3), np.uint8)
        dst[:,:,:]=img[:,:,:]

        masks = np.zeros((768, 768, 1), np.uint8)
        masks.fill(0)
        id0 = image['id']

        counts = 0

        contours = []
        for target in ann_Y0:
            if target['image_id']==id0:
                counts += 1
                j=0
                X=[]
                Y=[]
                for seg in target['segmentation'][0]:
                    if j == 0:
                        x = float(seg)
                        X.append(x)
                    else:
                        y = float(seg)
                        Y.append(y)
                    j = 1-j

                rr, cc = draw.polygon(Y, X)
                draw.set_color(src, [rr, cc], [0, 0, 255], 0.4)

                Point = np.zeros((len(Y), 2), dtype='int32')
                Point [:, 0] = X[:]
                Point [:, 1] = Y[:]
                #print(Point)
                cv.fillPoly(masks, np.array([Point],'int32'), 1)
        src[:, :, 0] = img[:, :, 0] #* 0.9 + masks[:, :, 0] * 0.1 * 255.0 / counts
        src[:, :, 1] = img[:, :, 1] #* 0.9 + masks[:, :, 0] * 0.1 * 255.0 / counts
        src[:, :, 2] = img[:, :, 2] * 0.2 + masks[:, :, 0] * 0.8 * 255.0 / counts

        mmcv.imshow(src,"Y",1)

        masks.fill(0)
        counts = 0
        for target in ann_Y1:
            if target['image_id']==id0:
                counts += 1
                CRLE    = target['segmentation']
                #print(CRLE)
                mask    = maskutil.decode(CRLE)
                mask    = np.reshape(mask, (img.shape[1], img.shape[0], 1))
                masks[:, :] = masks[:, :] + mask[:, :]

        dst[:, :, 0] = img[:, :, 0] * 0.2 + masks[:, :, 0] * 0.8 * 255.0/counts
        dst[:, :, 1] = img[:, :, 1] #* 0.5 + masks[:, :, 0] * 0.5 * 255.0/counts
        dst[:, :, 2] = src[:, :, 2] * 0.9 + masks[:, :, 0] * 0.1 * 255.0/counts
        mmcv.imshow(dst,"Y'")

    return 0

if __name__ == '__main__':
    main()