def produce_view(input_image, class_image, id2label, viewstyle): """Produce an image ready for plotting or saving.""" view = None if viewstyle == 'original': view = input_image elif (viewstyle == 'predictions') or (viewstyle == 'overlay'): view = color_class_image(class_image, id2label) if viewstyle == 'overlay': view = (0.5 * view.astype(np.float32) + 0.5 * input_image.astype(np.float32)).astype(np.uint8) else: print("Unknown view style") return view
def run(self, args_s=""): args_d = json.loads(args_s) iname = args_d['panid'] ext = args_d['ext'] filename = args_d['filename'] self.socketIO.emit('update', { 'id': iname, "phase": 3, 'val': -1, 'max': -1 }) self.socketIO.wait(seconds=1) class_scores = img_combine2.img_combine2( namedtuple('Struct', args_d.keys())(*args_d.values())) print("blended...") img = misc.imread("./{0}{1}".format(panid, ext)) img = misc.imresize(img, 10) class_image = np.argmax(class_scores, axis=2) pm = np.max(class_scores, axis=2) colored_class_image = utils.color_class_image(class_image, args_d['model']) #colored_class_image is [0.0-1.0] img is [0-255] alpha_blended = 0.5 * colored_class_image + 0.5 * img misc.imsave(panid + "_seg_blended" + ext, alpha_blended) # for filename in tqdm.tqdm(os.listdir('/tmp')): # if filename.endswith(".npy"): # try: # os.remove(filename) # except Exception: # pass self.socketIO.emit('update', { 'id': iname, "phase": 3, 'val': 1, 'max': 1 }) self.socketIO.wait(seconds=1) self.responseQueue.put(args_d['local_id'])
def on_request(self, *args): global mutex1, mutex2, mutex, mutex_data # tf.reset_default_graph() print("got request") data = args[0] filename, ext = splitext(data['input_path']) panid = basename(filename) # download file from upper server print("download...") sshdownload(data) args_d = {} remote_uuid = "{0}{1}".format(uuid.uuid4(), "_deeplearning") socketIO = SocketIO('localhost', ssht2.local_bind_port, LoggingNamespace) args_d['remote_uuid'] = remote_uuid args_d['socketIO'] = socketIO args_d['model'] = "pspnet50_ade20k" args_d['sliding'] = True args_d['flip'] = True args_d['multi_scale'] = True print("phase 1...") args_d['input_path'] = "./{0}{1}".format(panid, ext) args_d['output_path'] = "{2}/{0}{1}".format(panid, ext, config_p1_folder) pre_process.pre_process( namedtuple('Struct', args_d.keys())(*args_d.values())) print("phase 2...") # args_d['sess']=sess # args_d['model_ok']=pspnet args_d['input_path'] = config_p1_folder + '/' args_d['input_path_filter'] = panid args_d['output_path'] = config_p2_folder + '/' del args_d['socketIO'] mutex.acquire() with open("temp_arg.json", 'w+') as fout: fout.write(json.dumps(args_d)) mutex.release() # mutex1.put(args_d,block=True) print("sent task,wait response") while (1): # print("waiting...") mutex.acquire() if not os.path.exists("temp_arg.json"): break mutex.release() time.sleep(1) mutex.release() # mutex2.get(block=True) args_d['socketIO'] = socketIO print("phase 3...") args_d['input_path'] = "./{0}{1}".format(panid, ext) args_d['input_path2'] = "{2}/{0}{1}".format(panid, ext, config_p2_folder) args_d['output_path'] = "{2}/{0}{1}".format(panid, ext, config_p3_folder) class_scores = img_combine2.img_combine2( namedtuple('Struct', args_d.keys())(*args_d.values())) print("blended...") img = misc.imread("./{0}{1}".format(panid, ext)) img = misc.imresize(img, 10) class_image = np.argmax(class_scores, axis=2) pm = np.max(class_scores, axis=2) colored_class_image = utils.color_class_image(class_image, args_d['model']) #colored_class_image is [0.0-1.0] img is [0-255] alpha_blended = 0.5 * colored_class_image + 0.5 * img misc.imsave(filename + "_seg_blended" + ext, alpha_blended) print("upload...") sshupload(data, filename + "_seg_blended" + ext) print("garbage cleaning") print("success") self.emit("next")
input_shape=(768, 480), weights=args.weights) for i, img_path in enumerate(images): print("Processing image {} / {}".format(i + 1, len(images))) img = misc.imread(img_path, mode='RGB') cimg = misc.imresize(img, 20) # class_scores = predict_multi_scale(img, pspnet, EVALUATION_SCALES, sliding, flip) probs = pspnet.predict(cimg, args.flip) cm = np.argmax(probs, axis=2) pm = np.max(probs, axis=2) colored_class_image, color_names = utils.color_class_image( cm, args.model) count = collections.Counter(color_names) count = dict(count) y = sum(count.values()) for key, value in count.items(): # print(value, sum(count.values())) count[key] = value / y ##to sort in descending order according to the value count = sorted([(value, key) for (key, value) in count.items()], reverse=True)
pspnet = PSPNet50(nb_classes=150, input_shape=(473, 473), weights=args.model) elif "pspnet101" in args.model: if "cityscapes" in args.model: pspnet = PSPNet101(nb_classes=19, input_shape=(713, 713), weights=args.model) if "voc2012" in args.model: pspnet = PSPNet101(nb_classes=21, input_shape=(473, 473), weights=args.model) else: print("Network architecture not implemented.") if args.multi_scale: EVALUATION_SCALES = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75] # must be all floats! EVALUATION_SCALES = [0.15, 0.25, 0.5] # must be all floats! class_scores = predict_multi_scale(img, pspnet, EVALUATION_SCALES, args.sliding, args.flip) print("Writing results...") class_image = np.argmax(class_scores, axis=2) pm = np.max(class_scores, axis=2) colored_class_image = utils.color_class_image(class_image, args.model) # colored_class_image is [0.0-1.0] img is [0-255] alpha_blended = 0.5 * colored_class_image + 0.5 * img filename, ext = splitext(args.output_path) misc.imsave(filename + "_seg" + ext, colored_class_image) misc.imsave(filename + "_probs" + ext, pm) misc.imsave(filename + "_seg_blended" + ext, alpha_blended)
id = {label.id for label in labels if label.name == 'ceiling'} #todo get label and idddddd img = misc.imread('PSPNet-Keras-tensorflow-master/example_images/ade20k2.jpg') #create the neural network pspnet = PSPNet50(nb_classes=150, input_shape=(473, 473), weights='pspnet50_ade20k') #Run over input data class_scores = predict_multi_scale(img, pspnet, EVALUATION_SCALES, sliding, flip) print("Writing results...") class_image = np.argmax(class_scores, axis=2) #Get best classes (highest score!!) pm = np.max(class_scores, axis=2) colored_class_image = utils.color_class_image(class_image, 'ade20k') # colored_class_image is [0.0-1.0] img is [0-255] alpha_blended = 0.5 * colored_class_image + 0.5 * img #filename, ext = splitext('PSPNet-Keras-tensorflow-master/example_results/') #misc.imsave(filename + "_seg" + ext, colored_class_image) #misc.imsave(filename + "_probs" + ext, pm) #misc.imsave(filename + "_seg_blended" + ext, alpha_blended) misc.imshow(colored_class_image)
def main(): """Run when running this module as the primary one.""" EVALUATION_SCALES = [1.0] # must be all floats! parser = argparse.ArgumentParser() parser.add_argument("-m", "--model", type=str, default="pspnet50_ade20k", help="Model/Weights to use", choices=[ "pspnet50_ade20k", "pspnet101_cityscapes", "pspnet101_voc2012" ]) parser.add_argument("-i", "--input_path", type=str, default="../example_images", help="Path to the input images") parser.add_argument("-o", "--output_path", type=str, default="../example_results", help="Path to output") parser.add_argument("-g", "--groundtruth_path", type=str, default="../example_groundtruth", help="Path to groundtruth") parser.add_argument("--id", default="0") parser.add_argument( "-s", "--sliding", action="store_true", default=True, help= "Whether the network should be slided over the original image for prediction." ) parser.add_argument( "-f", "--flip", action="store_true", default=True, help= "Whether the network should predict on both image and flipped image.") parser.add_argument( "-ms", "--multi_scale", action="store_true", help="Whether the network should predict on multiple scales.") parser.add_argument("-hm", "--heat_maps", action="store_true", help="Whether the network should diplay heatmaps.") parser.add_argument("-v", "--vis", action="store_true", help="Whether an interactive plot should be diplayed.") parser.add_argument( "-cci", "--complete_coarse_image", action="store_true", help="Whether a coarse imae should be completed with predictions.") parser.add_argument( "-e", "--evaluate", action="store_true", help="Whether an evaluation against groundtruth should be attempted.") args = parser.parse_args() environ["CUDA_VISIBLE_DEVICES"] = args.id sess = tf.Session() K.set_session(sess) with sess.as_default(): print(args) import os cwd = os.getcwd() print("Running in %s" % cwd) image_paths = [] if isfile(args.input_path): image_paths.append(args.input_path) elif isdir(args.input_path): file_types = ("png", "jpg") for file_type in file_types: image_paths.extend( glob.glob(join(args.input_path + "/**/*." + file_type), recursive=True)) image_paths = sorted(image_paths) # print(image_paths) if "pspnet50" in args.model: pspnet = PSPNet50(nb_classes=150, input_shape=(473, 473), weights=args.model) if "ade20k" in args.model: from ade20k_labels import id2label, name2label elif "pspnet101" in args.model: if "cityscapes" in args.model: pspnet = PSPNet101(nb_classes=19, input_shape=(713, 713), weights=args.model) from cityscapes_labels import id2label, name2label if "voc2012" in args.model: pspnet = PSPNet101(nb_classes=21, input_shape=(473, 473), weights=args.model) from pascal_voc_labels import id2label, name2label else: print("Network architecture not implemented.") if args.multi_scale: EVALUATION_SCALES = [ 0.5, 0.75, 1.0, 1.25, 1.5, 1.75 ] # original implementation, must be all floats! for image_path in image_paths: image_name, ext = splitext(os.path.basename(image_path)) image_name = image_name.replace( "_leftImg8bit", "" ) # strip leftImg8bit tag for gt matching and producting groundtruth print("Predicting image name: %s" % (image_name + ext)) img = misc.imread(image_path) class_scores = predict_multi_scale(img, pspnet, EVALUATION_SCALES, args.sliding, args.flip) if args.heat_maps: # show_class_heatmap(class_scores, "person") show_class_heatmaps(class_scores) # visualize_prediction(img, class_scores, id2label) class_image = np.argmax(class_scores, axis=2) output_path, _ = splitext(args.output_path) if not os.path.exists(output_path): os.makedirs(output_path) output_path = join(output_path, image_name) print("Writing results to %s" % (output_path + ext)) confidence_map = np.max( class_scores, axis=2 ) # probability of the most likely class, a vage measure of the networks confidence colored_class_image = color_class_image(class_image, id2label) # colored_class_image is [0.0-1.0] img is [0-255] alpha_blended = 0.5 * colored_class_image + 0.5 * img if "cityscapes" in args.model: class_image = trainid_to_class_image(class_image) misc.imsave(output_path + "_gtFine_labelIds" + ext, class_image) misc.imsave(output_path + "_seg" + ext, colored_class_image) misc.imsave(output_path + "_probs" + ext, confidence_map) misc.imsave(output_path + "_seg_blended" + ext, alpha_blended) gt_path = find_matching_gt(args.groundtruth_path, image_name, args.model, verbose=True) if gt_path is not None: if args.complete_coarse_image: # only for cityscapes try: coarse_image = misc.imread(gt_path) class_image = complete_coarse_image( coarse_image, class_image) misc.imsave(output_path + "_gtFine_labelIds" + ext, class_image) except AttributeError as err: print("Warning: Could not read groundtruth: %s" % err) if args.evaluate: if "cityscapes" in args.model: evaluate_iou([class_image], [misc.imread(gt_path)], classes=35) else: # gt_image to class image gt_image = misc.imread(gt_path) gt_class_image = gt_image_to_class_image( gt_image, id2label) evaluate_iou([class_image], [gt_class_image], classes=pspnet.nb_classes) else: print("Could not find groundtruth for %s" % image_name)