import os
import sys
import random
import math
import numpy as np
import skimage.io
import matplotlib
import matplotlib.pyplot as plt
from mrcnn.config import Config
import mrcnn.model as modellib
from data import cityspace
from mrcnn import visualize
import cv2
from collections import namedtuple
import tensorflow as tf
class_names = ['BG','road','sidewalk','person','rider','car','truck','bus','motorcycle','bicycle',
               'building','wall','fence','pole','traffic sign','traffic light','vegetation','terrain',
               'sky','train']
# a label and all meta information
Label = namedtuple( 'Label' , [

    'name'        , # The identifier of this label, e.g. 'car', 'person', ... .
                    # We use them to uniquely name a class

    'id'          , # An integer ID that is associated with this label.
                    # The IDs are used to represent the label in ground truth images
                    # An ID of -1 means that this label does not have an ID and thus
                    # is ignored when creating ground truth images (e.g. license plate).
                    # Do not modify these IDs, since exactly these IDs are expected by the
                    # evaluation server.

    'trainId'     , # Feel free to modify these IDs as suitable for your method. Then create
                    # ground truth images with train IDs, using the tools provided in the
                    # 'preparation' folder. However, make sure to validate or submit results
                    # to our evaluation server using the regular IDs above!
                    # For trainIds, multiple labels might have the same ID. Then, these labels
                    # are mapped to the same class in the ground truth images. For the inverse
                    # mapping, we use the label that is defined first in the list below.
                    # For example, mapping all void-type classes to the same ID in training,
                    # might make sense for some approaches.
                    # Max value is 255!

    'category'    , # The name of the category that this label belongs to

    'categoryId'  , # The ID of this category. Used to create ground truth images
                    # on category level.

    'hasInstances', # Whether this label distinguishes between single instances or not

    'ignoreInEval', # Whether pixels having this class as ground truth label are ignored
                    # during evaluations or not

    'color'       , # The color of this label
    ] )
labels = [
    #       name                     id    trainId   category            catId     hasInstances   ignoreInEval   color
    Label(  'unlabeled'            ,  0 ,      255 , 'void'            , 0       , False        , True         , (  0,  0,  0) ),
    Label(  'ego vehicle'          ,  1 ,      255 , 'void'            , 0       , False        , True         , (  0,  0,  0) ),
    Label(  'rectification border' ,  2 ,      255 , 'void'            , 0       , False        , True         , (  0,  0,  0) ),
    Label(  'out of roi'           ,  3 ,      255 , 'void'            , 0       , False        , True         , (  0,  0,  0) ),
    Label(  'static'               ,  4 ,      255 , 'void'            , 0       , False        , True         , (  0,  0,  0) ),
    Label(  'dynamic'              ,  5 ,      255 , 'void'            , 0       , False        , True         , (111, 74,  0) ),
    Label(  'ground'               ,  6 ,      255 , 'void'            , 0       , False        , True         , ( 81,  0, 81) ),
    Label(  'road'                 ,  7 ,        0 , 'flat'            , 1       , False        , False        , (128, 64,128) ),
    Label(  'sidewalk'             ,  8 ,        1 , 'flat'            , 1       , False        , False        , (244, 35,232) ),
    Label(  'parking'              ,  9 ,      255 , 'flat'            , 1       , False        , True         , (250,170,160) ),
    Label(  'rail track'           , 10 ,      255 , 'flat'            , 1       , False        , True         , (230,150,140) ),
    Label(  'building'             , 11 ,        2 , 'construction'    , 2       , False        , False        , ( 70, 70, 70) ),
    Label(  'wall'                 , 12 ,        3 , 'construction'    , 2       , False        , False        , (102,102,156) ),
    Label(  'fence'                , 13 ,        4 , 'construction'    , 2       , False        , False        , (190,153,153) ),
    Label(  'guard rail'           , 14 ,      255 , 'construction'    , 2       , False        , True         , (180,165,180) ),
    Label(  'bridge'               , 15 ,      255 , 'construction'    , 2       , False        , True         , (150,100,100) ),
    Label(  'tunnel'               , 16 ,      255 , 'construction'    , 2       , False        , True         , (150,120, 90) ),
    Label(  'pole'                 , 17 ,        5 , 'object'          , 3       , False        , False        , (153,153,153) ),
    Label(  'polegroup'            , 18 ,      255 , 'object'          , 3       , False        , True         , (153,153,153) ),
    Label(  'traffic light'        , 19 ,        6 , 'object'          , 3       , False        , False        , (250,170, 30) ),
    Label(  'traffic sign'         , 20 ,        7 , 'object'          , 3       , False        , False        , (220,220,  0) ),
    Label(  'vegetation'           , 21 ,        8 , 'nature'          , 4       , False        , False        , (107,142, 35) ),
    Label(  'terrain'              , 22 ,        9 , 'nature'          , 4       , False        , False        , (152,251,152) ),
    Label(  'sky'                  , 23 ,       10 , 'sky'             , 5       , False        , False        , ( 70,130,180) ),
    Label(  'person'               , 24 ,       11 , 'human'           , 6       , True         , False        , (220, 20, 60) ),
    Label(  'rider'                , 25 ,       12 , 'human'           , 6       , True         , False        , (255,  0,  0) ),
    Label(  'car'                  , 26 ,       13 , 'vehicle'         , 7       , True         , False        , (  0,  0,142) ),
    Label(  'truck'                , 27 ,       14 , 'vehicle'         , 7       , True         , False        , (  0,  0, 70) ),
    Label(  'bus'                  , 28 ,       15 , 'vehicle'         , 7       , True         , False        , (  0, 60,100) ),
    Label(  'caravan'              , 29 ,      255 , 'vehicle'         , 7       , True         , True         , (  0,  0, 90) ),
    Label(  'trailer'              , 30 ,      255 , 'vehicle'         , 7       , True         , True         , (  0,  0,110) ),
    Label(  'train'                , 31 ,       16 , 'vehicle'         , 7       , True         , False        , (  0, 80,100) ),
    Label(  'motorcycle'           , 32 ,       17 , 'vehicle'         , 7       , True         , False        , (  0,  0,230) ),
    Label(  'bicycle'              , 33 ,       18 , 'vehicle'         , 7       , True         , False        , (119, 11, 32) ),
    Label(  'license plate'        , -1 ,       -1 , 'vehicle'         , 7       , False        , True         , (  0,  0,142) ),
]

name2label = { label.name : label for label in labels }
print(name2label['tunnel'].color)
#if __name__ == '__main__':

import argparse
# Parse command line arguments
parser = argparse.ArgumentParser(description='Inference Mask R-CNN on  cityspace.')
parser.add_argument('--modellogs', required=True,
                    metavar="/path/to/cityspace/",
                    help='Directory of the cityspace trained model logs')
parser.add_argument('--model', required=True,
                    metavar="/path/to/cityspace/",
                    help='Directory of the cityspace trained model')
parser.add_argument('--image_path', required=True,
                    metavar="/path/to/cityspace/",
                    help='Directory of the inferenced image')
args = parser.parse_args()
print("Model: ", args.model)
print("Model: ", args.modellogs)
print("image: ", args.image_path)

config = cityspace.cityspaceConfig()
class InferenceConfig(config.__class__):
    # Run detection on one image at a time
    GPU_COUNT = 1
    IMAGES_PER_GPU = 1

config = InferenceConfig()
config.display()
# Create model object in inference mode.
print(args.modellogs)
model = modellib.MaskRCNN(mode="inference", model_dir=args.modellogs, config=config)
# Load weights trained on MS-COCO
model.load_weights(args.model, by_name=True)
graph = tf.get_default_graph()
#qiq#    file_obj = open(args.image_path,'r')
#qiq#    content = file_obj.read()
#qiq#    imglists = content.strip().split('\n')
#qiq#    for imgpath in imglists:
def alls():
    for imgpath in os.listdir('/home/machine/Downloads/Mask_RCNN/test/tusimple/'):
        global model

        image = skimage.io.imread('/home/machine/Downloads/Mask_RCNN/test/tusimple/'+imgpath)
        # Run detections
        with graph.as_default():
            results = model.detect([image], verbose=1)
        r = results[0]
    #qiq#        masks = r['masks']
    #qiq#        class_ids = r['class_ids']
    #qiq#        scores = r['scores']
        mutex.acquire()
        visualize.display_instances(image,imgpath,name2label,r['rois'], r['masks'], r['class_ids'], class_names, r['scores'])
        mutex.release() #reject lock release
    end =time.time()
    print('Times:',end-start)
import time
import threading,multiprocessing
mutex = threading.Lock()
start =time.time()
for i in range(1):#multiprocessing.cpu_count()):
    t1 = threading.Thread(target=alls)
    t1.start()


#qiq#        png_count = 0
#qiq#        path = imgpath.split('.')[0].split('/')
#qiq#        result = '/home/machine/Downloads/Mask_RCNN/instances/'+path[len(path)-1]
#qiq#        [h,w,c] = np.shape(masks)
#qiq#        ff = open(result+'.txt','w+')
#qiq#        for k in range(c):
#qiq#            loc = np.where(masks[:,:,k]==1)
#qiq#            final_mask = image
#qiq#            y = loc[0]
#qiq#            x = loc[1]
#qiq#
#qiq#            final_mask[y,x,0] = final_mask[y,x,0] #only for test,non-zeros is required       BGR
#qiq#            final_mask[y,x,1] = final_mask[y,x,1]  #only for test,non-zeros is required
#qiq#            final_mask[y,x,2] = 255  #only for test,non-zeros is required
#qiq#        cv2.imwrite(result + str(png_count) + '.png', final_mask)
#qiq#        id = name2label[class_names[class_ids[k]]].id
#qiq#        png_count = png_count + 1
#qiq#        ff.write(result + str(png_count) + '.png'+' '+str(id)+' '+ str(scores[k])+'\n')
#qiq#        ff.close()

#qiq#        for k in range(c):
#qiq#            loc = np.where(masks[:,:,k]==1)
#qiq#            final_mask = np.zeros([h,w], dtype=np.uint8)
#qiq#            y = loc[0]
#qiq#            x = loc[1]
#qiq#            final_mask[y,x] = 255 #only for test,non-zeros is required
#qiq#            cv2.imwrite(result + str(png_count) + '.png', final_mask)
#qiq#        id = name2label[class_names[class_ids[k]]].id
#qiq#        png_count = png_count + 1
#qiq#        ff.write(result + str(png_count) + '.png'+' '+str(id)+' '+ str(scores[k])+'\n')
#qiq#        ff.close()

 

10-04 22:04