def load_files():
# Root directory of the project
ROOT_DIR = os.path.abspath("../")
# Import Mask RCNN
sys.path.append(ROOT_DIR) # To find local version of the library
# Import COCO config
sys.path.append(os.path.join(ROOT_DIR,
"samples/coco/")) # To find local version
import coco
# Directory to save logs and trained model
MODEL_DIR = os.path.join(ROOT_DIR, "logs")
# Local path to trained weights file
COCO_MODEL_PATH = os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
# Download COCO trained weights from Releases if needed
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
# Directory of images to run detection on
IMAGE_DIR = os.path.join(ROOT_DIR, "images")
class InferenceConfig(coco.CocoConfig):
# Set batch size to 1 since we'll be running inference on
# one image at a time. Batch size = GPU_COUNT * IMAGES_PER_GPU
GPU_COUNT = 1
IMAGES_PER_GPU = 1
config = InferenceConfig()
# config.display()
return MODEL_DIR, config, COCO_MODEL_PATH
def captureVideo():
# We use a K80 GPU with 24GB memory, which can fit 3 images.
ROOT_DIR = os.getcwd()
MODEL_DIR = os.path.join(ROOT_DIR, "logs")
VIDEO_DIR = os.path.join(ROOT_DIR, "videos")
VIDEO_SAVE_DIR = os.path.join(VIDEO_DIR, "save")
WEAPON_MODEL_PATH = "mask_rcnn_weapon_cfg_0009.h5"
if not os.path.exists(WEAPON_MODEL_PATH):
utils.download_trained_weights(WEAPON_MODEL_PATH)
config = PredictionConfig()
config.display()
model = modellib.MaskRCNN(mode="inference",
model_dir=MODEL_DIR,
config=config)
model.load_weights(WEAPON_MODEL_PATH, by_name=True)
class_names = ['BG', 'weapon']
capture = cv2.VideoCapture('video/trailer.mkv')
try:
if not os.path.exists(VIDEO_SAVE_DIR):
os.makedirs(VIDEO_SAVE_DIR)
except OSError:
print('Error: Creating directory of data')
frames = []
frame_count = 0
# these 2 lines can be removed if you dont have a 1080p camera.
capture.set(cv2.CAP_PROP_FRAME_WIDTH, 1920)
capture.set(cv2.CAP_PROP_FRAME_HEIGHT, 1080)
while True:
ret, frame = capture.read()
# Bail out when the video file ends
if not ret:
break
# Save each frame of the video to a list
frame_count += 1
frames.append(frame)
print('frame_count :{0}'.format(frame_count))
if len(frames) == config.BATCH_SIZE:
results = model.detect(frames, verbose=0)
print('Predicted')
for i, item in enumerate(zip(frames, results)):
frame = item[0]
r = item[1]
frame = display_instances(frame, r['rois'], r['masks'],
r['class_ids'], class_names,
r['scores'])
if frame is not None:
name = '{0}.jpg'.format(frame_count + i -
config.BATCH_SIZE)
name = os.path.join(VIDEO_SAVE_DIR, name)
cv2.imwrite(name, frame)
print('writing to file:{0}'.format(name))
# Clear the frames array to start the next batch
frames = []
capture.release()
def __init__(self):
if not os.path.exists(self.COCO_MODEL_PATH):
utils.download_trained_weights(self.COCO_MODEL_PATH)
config = InferenceConfig()
config.display()
with tf.device(self.DEVICE):
self.model = modellib.MaskRCNN(mode="inference",
model_dir=self.MODEL_DIR,
config=config)
self.model.load_weights(self.COCO_MODEL_PATH, by_name=True)
self.biggest_object = 0
self.object_area = 0
self.output = {}
def person_blocker(args):
# Required to load model, but otherwise unused
ROOT_DIR = os.getcwd()
COCO_MODEL_PATH = args.model or os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
MODEL_DIR = os.path.join(ROOT_DIR, "logs") # Required to load model
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
# Load model and config
config = InferenceConfig()
model = modellib.MaskRCNN(mode="inference",
model_dir=MODEL_DIR, config=config)
model.load_weights(COCO_MODEL_PATH, by_name=True)
image = imageio.imread(args.image)
# Create masks for all objects
results = model.detect([image], verbose=0)
r = results[0]
# Filter masks to only the selected objects
objects = np.array(args.objects)
# Object IDs:
if np.all(np.chararray.isnumeric(objects)):
object_indices = objects.astype(int)
# Types of objects:
else:
selected_class_ids = np.flatnonzero(np.in1d(get_class_names(),
objects))
object_indices = np.flatnonzero(
np.in1d(r['class_ids'], selected_class_ids))
mask_selected = np.sum(r['masks'][:, :, object_indices], axis=2)
mask_selected = mask_selected.astype(np.uint8)
# Dilate Mask
mask_selected = dilate_mask(mask_selected)
# Replace object masks with noise
# image_masked = image.copy()
# mask = create_mask_color(image, [255, 255, 255])
# image_masked[mask_selected > 0] = mask[mask_selected > 0]
# imageio.imwrite(args.output, image_masked)
mask_selected[mask_selected > 0] = 255
mask_selected = 255 - mask_selected
imageio.imwrite(args.output, mask_selected)
def continueTrainingCoCo(epochs):
COCO_MODEL_PATH = os.path.join(ROOT_DIR, "model", "mask_rcnn_coco.h5")
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
config = train_config()
config.display()
dataset = ShapesDataset(-1, 0, -1)
dataset.load_imgs(TRAIN_PATH)
dataset.prepare()
#print("Image Count: {}".format(len(dataset.image_ids)))
#print("Class Count: {}".format(dataset.num_classes))
for i, info in enumerate(dataset.class_info):
print("{:3}. {:50}".format(i, info['name']))
dataset_valid = ShapesDataset(-1, 1, 1)
dataset_valid.load_imgs(VALID_PATH)
dataset_valid.prepare()
model = modellib.MaskRCNN(mode="training",
config=config,
model_dir=MODEL_DIR)
model_path = model.find_last()[1]
if model_path:
print("Loading weights from " + model_path)
model.load_weights(model_path, by_name=True)
elif config.TRAIN_FROM_COCO == 1:
print('train from CoCo')
model.load_weights(COCO_MODEL_PATH,
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc",
"mrcnn_bbox", "mrcnn_mask"
])
else:
print('train from scrash')
print('start training')
model.train(
dataset,
dataset_valid,
learning_rate=config.LEARNING_RATE,
epochs=epochs,
#layers="heads",
layers="all",
argument=config.ARGUMENT)
def __init__(self, config):
K.clear_session()
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
class InferenceConfig(coco.CocoConfig):
GPU_COUNT = 1
IMAGES_PER_GPU = 1
config = InferenceConfig()
self.model = modellib.MaskRCNN(mode="inference",
model_dir=MODEL_DIR,
config=config)
self.model.load_weights(COCO_MODEL_PATH, by_name=True)
def person_blocker(args):
# If the output path does not exist, create it
if not os.path.exists(args.write_output):
os.makedirs(args.write_output)
# Required to load model, but otherwise unused
ROOT_DIR = os.getcwd()
COCO_MODEL_PATH = args.model or os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
MODEL_DIR = os.path.join(ROOT_DIR, "logs") # Required to load model
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
# Load model and config
config = InferenceConfig()
model = modellib.MaskRCNN(mode="inference",
model_dir=MODEL_DIR,
config=config)
model.load_weights(COCO_MODEL_PATH, by_name=True)
# Start reading the frames
reader = imageio.get_reader(args.image)
vlen = len(reader)
for i, image in enumerate(reader):
# Output frame number
print(str(i) + "/" + str(vlen))
# Create masks for all objects
results = model.detect([image], verbose=0)
r = results[0]
position_ids = [''.format(x) for x in range(r['class_ids'].shape[0])]
outstr = (args.write_output + "/labeled{:06d}.png").format(i)
visualize_labelmod.display_instances(
image,
r['rois'],
r['masks'],
r['class_ids'],
get_class_names(),
scores=r['scores'],
selected_class=args.selected_class,
outname=outstr)
def __init__(self, items=None):
"""Initialize the Coco Model
Arguments
---------
items: list-like
Only items from this list will be annotated, and the rest will be discarded.
If not provided, all masks are generated.
"""
super().__init__(name="Coco",
config=InferenceConfig(),
model_dir=MODEL_DIR,
class_names=class_names)
# Download COCO trained weights from Releases if needed
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
self.items = items or class_names
def load_model():
ROOT_DIR = os.getcwd()
COCO_MODEL_PATH = os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
MODEL_DIR = os.path.join(ROOT_DIR, "logs") # Required to load model
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
# Load model and config
config = InferenceConfig()
model = modellib.MaskRCNN(mode="inference",
model_dir=MODEL_DIR,
config=config)
model.load_weights(COCO_MODEL_PATH, by_name=True)
return model
def load_mask_rcnn():
ROOT_DIR = os.getcwd()
MODEL_DIR = os.path.join(ROOT_DIR, "logs")
COCO_MODEL_PATH = os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
class InferenceConfig(coco.CocoConfig):
GPU_COUNT = 1
IMAGES_PER_GPU = 1
config = InferenceConfig()
config.display()
DEVICE = "/cpu:0"
with tf.device(DEVICE):
model = modellib.MaskRCNN(mode="inference",
model_dir=MODEL_DIR,
config=config)
model.load_weights(COCO_MODEL_PATH, by_name=True)
class_names = [
'BG', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'stop sign',
'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep',
'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella',
'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard',
'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard',
'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork',
'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange',
'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair',
'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',
'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
'scissors', 'teddy bear', 'hair drier', 'toothbrush'
]
return model
def load_weights(model, _config, init_with_override=None):
init_with = _config.init_with if init_with_override is None else init_with_override # imagenet, coco, or last
if init_with == "imagenet":
model.load_weights(model.get_imagenet_weights(), by_name=True)
elif init_with == "coco":
if not os.path.exists(_config.COCO_MODEL_PATH):
utils.download_trained_weights(_config.COCO_MODEL_PATH)
# Load weights trained on MS COCO, but skip layers that
# are different due to the different number of classes
# See README for instructions to download the COCO weights
model.load_weights(_config.COCO_MODEL_PATH,
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc",
"mrcnn_bbox", "mrcnn_mask"
])
elif init_with == "last":
# Load the last model you trained and continue training
model.load_weights(model.find_last()[1], by_name=True)
return model
import time
import balloon
import utils
import model as modellib
#socket binding to unity binding to socket 5555
import zmq
context = zmq.Context()
socket = context.socket(zmq.REP)
socket.bind("tcp://*:5555")
ROOT_DIR = os.getcwd()
MODEL_DIR = os.path.join(ROOT_DIR, "logs")
SODA_WEIGHTS_PATH = os.path.join(ROOT_DIR, "mask_rcnn_soda_can.h5")
COCO_MODEL_PATH = os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
if not os.path.exists(SODA_WEIGHTS_PATH):
utils.download_trained_weights(SODA_WEIGHTS_PATH)
config = balloon.BalloonConfig()
class InferenceConfig(config.__class__):
GPU_COUNT = 1
IMAGES_PER_GPU = 1
config = InferenceConfig()
config.display()
model = modellib.MaskRCNN(mode="inference",
model_dir=MODEL_DIR,
config=config)
model.load_weights(SODA_WEIGHTS_PATH, by_name=True)
def person_blocker(args):
# Required to load model, but otherwise unused
ROOT_DIR = os.getcwd()
COCO_MODEL_PATH = args.model or os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
MODEL_DIR = os.path.join(ROOT_DIR, "logs") # Required to load model
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
# Load model and config
config = InferenceConfig()
model = modellib.MaskRCNN(mode="inference",
model_dir=MODEL_DIR, config=config)
model.load_weights(COCO_MODEL_PATH, by_name=True)
image = imageio.imread(filename)
# Create masks for all objects
results = model.detect([image], verbose=0)
r = results[0]
if args.labeled:
position_ids = ['[{}]'.format(x)
for x in range(r['class_ids'].shape[0])]
visualize.display_instances(image, r['rois'],
r['masks'], r['class_ids'],
get_class_names(), position_ids)
sys.exit()
# Filter masks to only the selected objects
objects = np.array(args.objects)
# Object IDs:
if np.all(np.chararray.isnumeric(objects)):
object_indices = objects.astype(int)
# Types of objects:
else:
selected_class_ids = np.flatnonzero(np.in1d(get_class_names(),
objects))
object_indices = np.flatnonzero(
np.in1d(r['class_ids'], selected_class_ids))
mask_selected = np.sum(r['masks'][:, :, object_indices], axis=2)
# Replace object masks with noise
mask_color = string_to_rgb_triplet(args.color)
image_masked = image.copy()
noisy_color = create_noisy_color(image, mask_color)
image_masked[mask_selected > 0] = noisy_color[mask_selected > 0]
img_dir = '/Volumes/seagate/projects/person-blocker/images2/'
img_pre = 'person_blocked_{0}'.format(strftime("%Y%m%d%H%M%S",gmtime()))
img_name = img_dir + img_pre + '.png'
gif_name = img_dir + img_pre + '.gif'
imageio.imwrite(img_name, image_masked)
# Create GIF. The noise will be random for each frame,
# which creates a "static" effect
# this works great, but takes some time and produces 7+ meg file
#images = [image_masked]
#num_images = 10 # should be a divisor of 30
#
#for _ in range(num_images - 1):
# new_image = image.copy()
# noisy_color = create_noisy_color(image, mask_color)
# new_image[mask_selected > 0] = noisy_color[mask_selected > 0]
# images.append(new_image)
#
#imageio.mimsave(gif_name, images, fps=30., subrectangles=True)
# print json
try:
# Create unique image name
uniqueid = 'person_uuid_{0}_{1}'.format(strftime("%Y%m%d%H%M%S%f",gmtime()),uuid.uuid4())
host = os.uname()[1]
currenttime= strftime("%Y-%m-%d %H:%M:%S",gmtime())
ipaddress = IP_address()
end = time.time()
row = { 'uuid': uniqueid, 'runtime': str(round(end - start)), 'host': host, 'ts': currenttime, 'ipaddress': ipaddress, 'imagefilename': img_pre, 'originalfilename': filename }
print( json.dumps(row) )
except:
print("{\"message\": \"Failed to run\"}")
def seg_main():
"""
test everything
"""
import os
import sys
import coco
import utils
import model as modellib
ROOT_DIR = os.getcwd()
MODEL_DIR = os.path.join(ROOT_DIR, "logs")
COCO_MODEL_PATH = os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
class InferenceConfig(coco.CocoConfig):
GPU_COUNT = 1
IMAGES_PER_GPU = 1
config = InferenceConfig()
config.display()
model = modellib.MaskRCNN(mode="inference",
model_dir=MODEL_DIR,
config=config)
model.load_weights(COCO_MODEL_PATH, by_name=True)
class_names = [
'BG', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'stop sign',
'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep',
'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella',
'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard',
'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard',
'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork',
'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange',
'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair',
'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',
'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
'scissors', 'teddy bear', 'hair drier', 'toothbrush'
]
capture = bridge.imgmsg_to_cv2(data, "bgr8")
# these 2 lines can be removed if you dont have a 1080p camera.
capture.set(cv2.CAP_PROP_FRAME_WIDTH, 1920)
capture.set(cv2.CAP_PROP_FRAME_HEIGHT, 1080)
ret, frame = capture.read()
frame = cv2.resize(frame, (480 * 2, 340 * 2))
results = model.detect([frame], verbose=0)
r = results[0]
frame = display_instances(frame, r['rois'], r['masks'], r['class_ids'],
class_names, r['scores'])
cv2.imshow('frame', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
publisher(capture)
capture.release()
cv2.destroyAllWindows()
NUM_CLASSES = nr_classes
config = TacoTestConfig()
config.display()
# Create model
if args.command == "train":
model = MaskRCNN(mode="training", config=config, model_dir=DEFAULT_LOGS_DIR)
else:
model = MaskRCNN(mode="inference", config=config, model_dir=DEFAULT_LOGS_DIR)
# Select weights file to load
if args.model.lower() == "coco":
model_path = COCO_MODEL_PATH
# Download weights file
if not os.path.exists(model_path):
utils.download_trained_weights(model_path)
elif args.model.lower() == "last":
# Find last trained weights
model_path = model.find_last()[1]
elif args.model.lower() == "imagenet":
# Start from ImageNet trained weights
model_path = model.get_imagenet_weights()
else:
model_path = args.model
# Load weights
if args.model.lower() == "coco":
# Exclude the last layers because they require a matching
# number of classes
model.load_weights(model_path, by_name=True, exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc",
def main():
# Root directory of the project
ROOT_DIR = os.getcwd()
# Directory to save logs and trained model
MODEL_DIR = os.path.join(ROOT_DIR, "logs")
# Local path to trained weights file
COCO_MODEL_PATH = os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
# Download COCO trained weights from Releases if needed
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
class InferenceConfig(coco.CocoConfig):
# Set batch size to 1 since we'll be running inference on
# one image at a time. Batch size = GPU_COUNT * IMAGES_PER_GPU
GPU_COUNT = 1
IMAGES_PER_GPU = 8 # 8 is maximum for single P100.
config = InferenceConfig()
config.display()
# Create model object in inference mode.
model = modellib.MaskRCNN(mode="inference",
model_dir=MODEL_DIR,
config=config)
# Load weights trained on MS-COCO
model.load_weights(COCO_MODEL_PATH, by_name=True)
print("Successfully load coco pretrained model.")
# COCO Class names
# Index of the class in the list is its ID. For example, to get ID of
# the teddy bear class, use: class_names.index('teddy bear')
class_names = [
'BG', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'stop sign',
'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep',
'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella',
'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard',
'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard',
'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork',
'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange',
'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair',
'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',
'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
'scissors', 'teddy bear', 'hair drier', 'toothbrush'
]
# read scene
info_dir = "../../detrac/DETRAC-Train-Annotations-XML/"
video_dir = "../../detrac/Insight-MVT_Annotation_Train/"
save_dir = "../../detrac/train_detect_output/"
if not os.path.isdir(save_dir):
os.makedirs(save_dir)
videonames = [x for x in os.listdir(video_dir) if x.startswith("MVI")]
print(videonames)
batch_size = config.GPU_COUNT * config.IMAGES_PER_GPU
for videoname in videonames:
print("Processing scene {}...".format(videoname))
video_files = sorted([
img for img in os.listdir(os.path.join(video_dir, videoname))
if img.endswith(".jpg")
])
video_info = parse_scene_info(
os.path.join(info_dir, videoname + ".xml"))
#vid = imageio.get_reader(video_file, 'ffmpeg')
if video_info["weather"] == "night":
print("Skipping {} due to night.".format(videoname))
continue
save_pkl_dir = os.path.join(save_dir, videoname)
if not os.path.isdir(save_pkl_dir):
os.makedirs(save_pkl_dir)
start_point = 0 # set the start frame for detection
else:
start_point = len(os.listdir(save_pkl_dir))
# tqdm progress bar
pbar = tqdm.tqdm(total=len(video_files) - start_point)
for fnum in range(start_point, len(video_files), batch_size):
batch_data = []
for i in range(batch_size):
if fnum + i < len(video_files):
batch_data.append(
cv2.imread(
os.path.join(video_dir, videoname,
video_files[fnum + i])))
else:
batch_data.append(np.zeros((960, 540, 3)))
#batch_data = np.array(batch_data)
results = model.detect(batch_data, verbose=0)
for i, r in enumerate(results):
## transform mask to contours
print("frame {} detects {} objects".format(
fnum + i, r['rois'].shape[0]))
contours = []
for m in r['masks'].transpose(2, 0, 1):
contours.append(mask_to_contours(m.astype('uint8')))
r['contours'] = contours
r.pop(
'masks', None
) # This will return my_dict[key] if key exists in the dictionary, and None otherwise.
## save a single pkl for each frame
if fnum + i < len(video_files):
with open(
os.path.join(
save_pkl_dir,
video_files[fnum + i].replace(".jpg", "") +
".pkl"), "wb") as f:
pickle.dump(r, f, protocol=2)
pbar.update(1)
pbar.close()
def person_blocker(args):
# Required to load model, but otherwise unused
ROOT_DIR = os.getcwd()
SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
COCO_MODEL_PATH = args.model or os.path.join(SCRIPT_DIR,
"mask_rcnn_coco.h5")
MODEL_DIR = os.path.join(SCRIPT_DIR, "logs") # Required to load model
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
# Load model and config
config = InferenceConfig()
model = modellib.MaskRCNN(mode="inference",
model_dir=MODEL_DIR,
config=config)
model.load_weights(COCO_MODEL_PATH, by_name=True)
image = imageio.imread(args.infile)
# Create masks for all objects
results = model.detect([image], verbose=0)
r = results[0]
dirname = os.path.dirname(args.infile)
basename = os.path.basename(args.infile)
barename = os.path.splitext(basename)[0]
if args.objects is None:
# now paste it all together
outfile = os.path.join(dirname, "labels_{}.png".format(barename))
position_ids = [
'[{}]'.format(x) for x in range(r['class_ids'].shape[0])
]
print("Saving: {}".format(outfile))
visualize.display_instances(image,
r['rois'],
r['masks'],
r['class_ids'],
get_class_names(),
position_ids,
outfile=outfile)
sys.exit()
# Object IDs:
indices_list = []
objects_list = list(args.objects.split(","))
for objects_entry in objects_list:
if np.chararray.isnumeric(objects_entry):
indices_list += [objects_entry]
else:
selected_class_ids = np.flatnonzero(
np.in1d(get_class_names(), [objects_entry]))
indices_list += np.flatnonzero(
np.in1d(r['class_ids'], selected_class_ids)).tolist()
object_indices = np.asarray(indices_list).astype(int)
mask_selected = np.sum(r['masks'][:, :, object_indices], axis=2)
# Replace object masks with noise
mask_colors = list(map(string_to_rgb_triplet, args.colors.split(",")))
if args.bgcolor.lower() != "none":
bg_color = string_to_rgb_triplet(args.bgcolor)
image_masked = np.full(shape=(image.shape[0], image.shape[1], 3),
fill_value=bg_color).astype(np.uint8)
else:
image_masked = image.copy()
noisy_color = create_noisy_color(image, mask_colors[0])
image_masked[mask_selected > 0] = noisy_color[mask_selected > 0]
outfile = os.path.join(dirname, "mask_{}.png".format(barename))
print("Saving: {}".format(outfile))
imageio.imwrite(outfile, image_masked)
def __init__(self):
"""Initialize a MaskRCNNNode
Parameters
----------
Returns
----------
- <obj>: MaskRCNNNode
A Mask RCNN instantiation.
"""
self._cv_bridge = CvBridge()
self._class_names = rospy.get_param('~class_names', CLASS_NAMES)
self._class_colors = visualize.random_colors(len(CLASS_NAMES))
self._visualization = rospy.get_param('~visualization', True)
#
# network configuration
#
config = InferenceConfig()
config.display()
#
# model in inference mode
#
self._model = modellib.MaskRCNN(mode="inference",
model_dir="",
config=config)
#
# mutual exclusive lock for handling image messages.
#
self._last_msg = None
self._msg_lock = threading.Lock()
#
# publisher
#
self._detection_pub = rospy.Publisher('~detection',
mask_rcnn_ros.msg.Detection,
queue_size=1)
self._vis_pub = rospy.Publisher('~visualization',
sensor_msgs.msg.Image,
queue_size=1)
self._publish_rate = rospy.get_param('~publish_rate', 100)
#
# tensorflow graph
#
self._graph = tf.get_default_graph()
#
# Load weights trained on MS-COCO, download COCO trained weights from
# releases if needed
#
model_path = rospy.get_param('~model_path', COCO_MODEL_PATH)
if model_path == COCO_MODEL_PATH and not os.path.exists(
COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
self._model.load_weights(model_path, by_name=True)
def main(args):
# Root directory of the project
ROOT_DIR = os.getcwd()
# Directory to save logs and trained model
MODEL_DIR = os.path.join(ROOT_DIR, "logs")
if not os.path.exists(MODEL_DIR):
os.mkdir(MODEL_DIR)
# Local path to trained weights file
COCO_MODEL_PATH = os.path.join(MODEL_DIR, "mask_rcnn_coco.h5")
# Download COCO trained weights from Releases if needed
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
# data path
DATA_PATH = args.data_path
# Get train and test IDs
data_ids = next(os.walk(DATA_PATH))[1]
# create validation ids
train_ids, val_ids = train_test_split(data_ids, test_size=0.1)
# dataset name
dataset_name = os.path.basename(args.data_path)
# dataset config
config = DSBConfig()
config.NAME = dataset_name
config.STEPS_PER_EPOCH = int(
len(data_ids) / (config.GPU_COUNT * config.IMAGES_PER_GPU))
config.VALIDATION_STEPS = int(
len(val_ids) / (config.GPU_COUNT * config.IMAGES_PER_GPU))
config.display()
# dataset
# Training dataset
dataset_train = DSBDataset()
dataset_train.load_bowl(args.data_path)
dataset_train.prepare()
# Validation dataset
dataset_val = DSBDataset()
dataset_val.load_bowl(args.data_path)
dataset_val.prepare()
# Create model in training mode
model = modellib.MaskRCNN(mode="training",
config=config,
model_dir=MODEL_DIR)
if args.init_with == "imagenet":
model.load_weights(model.get_imagenet_weights(), by_name=True)
elif args.init_with == "coco":
# Load weights trained on MS COCO, but skip layers that
# are different due to the different number of classes
# See README for instructions to download the COCO weights
model.load_weights(COCO_MODEL_PATH,
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc",
"mrcnn_bbox", "mrcnn_mask"
])
elif args.init_with == "last":
# Load the last model you trained and continue training
model.load_weights(model.find_last()[1], by_name=True)
else:
print("wrong mode")
# Train the head branches
# Passing layers="heads" freezes all layers except the head
# layers. You can also pass a regular expression to select
# which layers to train by name pattern.
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=args.epochs,
layers='heads')
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=args.epochs * 2,
layers='4+')
# Fine tune all layers
# Passing layers="all" trains all layers. You can also
# pass a regular expression to select which layers to
# train by name pattern.
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE,
epochs=args.epochs * 3,
layers="all")
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE / 10,
epochs=args.epochs * 4,
layers="all")
model.train(dataset_train,
dataset_val,
learning_rate=config.LEARNING_RATE / 100,
epochs=args.epochs * 5,
layers="all")
if __name__ == '__main__':
ROOT_DIR = os.path.abspath("../")
sys.path.append(os.path.join(ROOT_DIR, "samples/coco/")) # To find local version
sys.path.append(os.path.join(ROOT_DIR, "mrcnn/")) # To find local version
import coco
import utils
import model as modellib
MODEL_DIR = os.path.join(ROOT_DIR, "logs")
COCO_MODEL_PATH = os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
options = {
'threshold': 0.5, # 阈值
'origin': 'sample_video/gakki_cut2_origin.flv', # 原始视频
'danmu': 'sample_video/gakki_cut2_danmu.flv', # 弹幕视频
'saveVideo': True,
'output': 'output/gakki_cut2_2.avi',
'keep': -1, # 处理多少秒，-1代表处理完整视频
}
class InferenceConfig(coco.CocoConfig):
GPU_COUNT = 1
IMAGES_PER_GPU = 1
DETECTION_MIN_CONFIDENCE = options.get('threshold')
def person_blocker(args):
# If the output path does not exist, create it
if not os.path.exists(args.write_output):
os.makedirs(args.write_output)
# Required to load model, but otherwise unused
ROOT_DIR = os.getcwd()
COCO_MODEL_PATH = args.model or os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
MODEL_DIR = os.path.join(ROOT_DIR, "logs") # Required to load model
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
# Load model and config
config = InferenceConfig()
model = modellib.MaskRCNN(mode="inference",
model_dir=MODEL_DIR, config=config)
model.load_weights(COCO_MODEL_PATH, by_name=True)
# Start reading the frames
reader = imageio.get_reader(args.image)
vlen = len(reader)
for i, image in enumerate(reader):
# Output frame number
print(str(i)+"/"+str(vlen))
# Create masks for all objects
results = model.detect([image], verbose=0)
r = results[0]
# if args.labeled:
# position_ids = ['[{}]'.format(x)
# for x in range(r['class_ids'].shape[0])]
# visualize.display_instances(image, r['rois'],
# r['masks'], r['class_ids'],
# get_class_names(), position_ids)
# sys.exit()
# Filter masks to only the selected objects
objects = np.array(args.objects)
# Object IDs:
if np.all(np.chararray.isnumeric(objects)):
object_indices = objects.astype(int)
# Types of objects:
else:
selected_class_ids = np.flatnonzero(np.in1d(get_class_names(),
objects))
object_indices = np.flatnonzero(
np.in1d(r['class_ids'], selected_class_ids))
mask_selected = np.sum(r['masks'][:, :, object_indices], axis=2)
# Replace object masks with noise
mask_color = string_to_rgb_triplet(args.color)
image_masked = image.copy()
noisy_color = create_noisy_color(image, mask_color)
image_masked[mask_selected > 0] = noisy_color[mask_selected > 0]
# Write number of detected objects
n_persons = sum(r['class_ids'] == 1)
img = Image.fromarray(image_masked.astype(np.uint8), 'RGB')
draw = ImageDraw.Draw(img)
font = ImageFont.truetype("arial.ttf", 60)
draw.text((0, 0), "N="+str(n_persons), fill=(255,0,0), font = font)
# plt.imshow(image_masked.astype(np.uint8))
# plt.text(0, 0, "N = " + str(n_persons), fontsize=20, color = "red")
# Save masked frame
#plt.show()
outstr = (args.write_output + "/frame{:06d}.jpg").format(i)
img.save(outstr)
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--input_name",
type=str,
required=True,
help="Input image name")
parser.add_argument("--output_name",
type=str,
required=True,
help="Output image name")
args = parser.parse_args()
# Root directory of the project
ROOT_DIR = os.getcwd()
# Directory to save logs and trained model
MODEL_DIR = os.path.join(ROOT_DIR, "logs")
# Local path to trained weights file
COCO_MODEL_PATH = os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
# Download COCO trained weights from Releases if needed
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
class InferenceConfig(coco.CocoConfig):
# Set batch size to 1 since we'll be running inference on
# one image at a time. Batch size = GPU_COUNT * IMAGES_PER_GPU
GPU_COUNT = 1
IMAGES_PER_GPU = 1
config = InferenceConfig()
# Create model object in inference mode.
model = modellib.MaskRCNN(mode="inference",
model_dir=MODEL_DIR,
config=config)
# Load weights trained on MS-COCO
model.load_weights(COCO_MODEL_PATH, by_name=True)
class_names = [
'BG', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'stop sign',
'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep',
'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella',
'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard',
'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard',
'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork',
'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange',
'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair',
'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',
'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
'scissors', 'teddy bear', 'hair drier', 'toothbrush', 'bottle',
'microphone'
]
# Load image
image = skimage.io.imread(args.input_name)
# Run detection
results = model.detect([image], verbose=1)
# Visualize results
r = results[0]
# Blur backround of the image and save it with output_name
visualize.display_blurred(image,
r['rois'],
r['masks'],
r['class_ids'],
class_names,
r['scores'],
name=args.output_name)
def test_simple(params):
"""Test function."""
import os
import sys
import coco
import utils
from mrcnn.config import Config
ROOT_DIR = os.getcwd()
MODEL_DIR = os.path.join(ROOT_DIR, "logs")
COCO = os.path.normpath(os.getcwd() + os.sep + os.pardir)
COCO = os.path.join(COCO +os.sep,"Mask RCNN" )
COCO_MODEL_PATH = os.path.join(COCO, "mask_rcnn_coco.h5")
#print(COCO_MODEL_PATH)
if os.path.isdir('Detection') is False:
os.mkdir('Detection')
DET_DIR = os.path.join(ROOT_DIR, "Detection")
DET_PATH = DET_DIR + os.sep
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
class CocoConfig(Config):
"""Configuration for training on MS COCO.
Derives from the base Config class and overrides values specific
to the COCO dataset.
"""
# Give the configuration a recognizable name
NAME = "coco"
# We use a GPU with 12GB memory, which can fit two images.
# Adjust down if you use a smaller GPU.
IMAGES_PER_GPU = 2
# Uncomment to train on 8 GPUs (default is 1)
# GPU_COUNT = 8
# Number of classes (including background)
# NUM_CLASSES = 37 # COCO has 80 classes
NUM_CLASSES = 81
class InferenceConfig(CocoConfig):
# Set batch size to 1 since we'll be running inference on
# one image at a time. Batch size = GPU_COUNT * IMAGES_PER_GPU
GPU_COUNT = 1
IMAGES_PER_GPU = 1
# MAX_GT_INSTANCES = 100
# TRAIN_ROIS_PER_IMAGE = 50
# BACKBONE = "resnet50" #not working at all!
# RPN_ANCHOR_STRIDE = 2
# POST_NMS_ROIS_TRAINING = 1000
# POST_NMS_ROIS_INFERENCE = 500
# IMAGE_MIN_DIM = 400 # really much faster but bad results
# IMAGE_MAX_DIM = 640
# DETECTION_MAX_INSTANCES = 50 #a little faster but some instances not recognized
config = InferenceConfig()
config.display()
left = tf.placeholder(tf.float32, [2, args.input_height, args.input_width, 3])
modeld = MonodepthModel(params, "test", left, None)
modelrcnn = modellib.MaskRCNN(
mode="inference", model_dir=MODEL_DIR, config=config
)
modelrcnn.load_weights(COCO_MODEL_PATH, by_name=True)
class_names = [
'BG', 'person', 'bicycle', 'car', 'motorcycle', 'airplane',
'bus', 'train', 'truck', 'boat', 'traffic light',
'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird',
'cat', 'dog', 'horse', 'sheep', 'cow', 'elephant', 'bear',
'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie',
'suitcase', 'frisbee', 'skis', 'snowboard', 'sports ball',
'kite', 'baseball bat', 'baseball glove', 'skateboard',
'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup',
'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple',
'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza',
'donut', 'cake', 'chair', 'couch', 'potted plant', 'bed',
'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote',
'keyboard', 'cell phone', 'microwave', 'oven', 'toaster',
'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors',
'teddy bear', 'hair drier', 'toothbrush'
]
now = datetime.now()
directions_result = gmaps.directions("Dejvice, Prague 6",
"Charles Square, Nové Město, Praha",
mode="transit",
departure_time=now)
# api = overpy.Overpass()
#
# # fetch all ways and nodes
# result = api.query("""way
# ["name"="Běžecká"]
# (50.07,14.0,50.8,14.4);
# /*added by auto repair*/
# (._;>;);
# /*end of auto repair*/
# out;
# """)
location1 = []
location = ''
abc = polyline.decode(directions_result[0]['overview_polyline']['points'])
for i in range(0, len(abc)):
location1 = str(abc[i])
location += location1.strip(')(') + '; '
#result = api.query("node(50.077167,14.419660,50.077668,14.429223);out;")
# print(len(result.nodes))
# for node in result.nodes:
# #print(" Lat: %f, Lon: %f" % (node.lat, node.lon))
# lat = str(node.lat)
# lon = str(node.lon)
# location1 = lat + ',' + lon + '; '
# location += location1
# print(location)
# location1 = []
# location = ''
# for i in range(0, 5):
# lat = str((50.0753397 - i * 0.0001))
# lon = str(14.4189888)
# location1 = lat + ',' + lon + '; '
# location += location1
apiargs = {
'location': location ,#'50.0753397,14.4189888 ; 50.0795436,14.3907308 ;50.10291748018805, 14.39132777985096',
'size': '640x640',
'heading': '90',
'fov': '90',
'key': 'AIzaSyCciJlgQzOFXZXhvM1ORscu0Cj5dj-lTRo',
'pitch': '0'
}
# Get a list of all possible queries from multiple parameters
api_list = google_streetview.helpers.api_list(apiargs)
# Create a results object for all possible queries
resultsg = google_streetview.api.results(api_list)
# Preview results
# resultsg.preview()
# Download images to directory 'downloads'
resultsg.download_links('Downloads')
# Save metadata
# resultsg.save_metadata('metadata.json')
onlyfiles = []
while True:
# ret , frame = capture.read()
# input_image = frame
images = os.path.join(ROOT_DIR, 'Downloads')
for f in listdir(images):
if f is not 'metadat.json':
onlyfiles.append(f)
onlyfiles = [f for f in listdir(images) if isfile(join(images, f))]
frame = np.empty(len(onlyfiles), dtype=object)
for n in range(0, len(onlyfiles) - 1):
frame = cv2.imread(join(images, onlyfiles[n]))
input_image = frame
original_height, original_width, num_channels = input_image.shape
input_image = scipy.misc.imresize(input_image, [args.input_height, args.input_width], interp='lanczos')
input_image = input_image.astype(np.float32) / 255
input_images = np.stack((input_image, np.fliplr(input_image)), 0)
# SESSION
config = tf.ConfigProto(allow_soft_placement=True)
sess = tf.Session(config=config)
# INIT
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
coordinator = tf.train.Coordinator()
disp = sess.run(modeld.disp_left_est[0], feed_dict={left: input_images})
disp_pp = post_process_disparity(disp.squeeze()).astype(np.float32)
results = modelrcnn.detect([frame], verbose=0)
r = results[0]
disp_to_img = scipy.misc.imresize(disp_pp.squeeze(), [original_height, original_width])
frame = display_instances(
frame, r['rois'], r['masks'], r['class_ids'], class_names, r['scores'],resultsg
)
cv2.imwrite(DET_PATH + str(n) + '.jpeg', frame)
cv2.destroyAllWindows()
break
map.save(outfile='map.html')
config.display()
# Create model
if args.command == "train":
model = modellib.MaskRCNN(mode="training", config=config,
model_dir=args.logs)
else:
model = modellib.MaskRCNN(mode="inference", config=config,
model_dir=args.logs)
# Select weights file to load
if args.weights.lower() == "coco":
weights_path = COCO_WEIGHTS_PATH
# Download weights file
if not os.path.exists(weights_path):
utils.download_trained_weights(weights_path)
elif args.weights.lower() == "last":
# Find last trained weights
weights_path = model.find_last()[1]
elif args.weights.lower() == "imagenet":
# Start from ImageNet trained weights
weights_path = model.get_imagenet_weights()
else:
weights_path = args.weights
# Load weights
print("Loading weights ", weights_path)
if args.weights.lower() == "coco":
# Exclude the last layers because they require a matching
# number of classes
model.load_weights(weights_path, by_name=True, exclude=[
def test_simple(params):
"""Test function."""
import os
import sys
import coco
import utils
from mrcnn.config import Config
ROOT_DIR = os.getcwd()
MODEL_DIR = os.path.join(ROOT_DIR, "logs")
COCO_MODEL_PATH = os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
class CocoConfig(Config):
"""Configuration for training on MS COCO.
Derives from the base Config class and overrides values specific
to the COCO dataset.
"""
# Give the configuration a recognizable name
NAME = "coco"
# We use a GPU with 12GB memory, which can fit two images.
# Adjust down if you use a smaller GPU.
IMAGES_PER_GPU = 2
# Uncomment to train on 8 GPUs (default is 1)
# GPU_COUNT = 8
# Number of classes (including background)
# NUM_CLASSES = 37 # COCO has 80 classes
NUM_CLASSES = 81
class InferenceConfig(CocoConfig):
# Set batch size to 1 since we'll be running inference on
# one image at a time. Batch size = GPU_COUNT * IMAGES_PER_GPU
GPU_COUNT = 1
IMAGES_PER_GPU = 1
# MAX_GT_INSTANCES = 100
# TRAIN_ROIS_PER_IMAGE = 50
# BACKBONE = "resnet50" #not working at all!
# RPN_ANCHOR_STRIDE = 2
POST_NMS_ROIS_TRAINING = 1000
POST_NMS_ROIS_INFERENCE = 500
IMAGE_MIN_DIM = 400 # really much faster but bad results
IMAGE_MAX_DIM = 512
# DETECTION_MAX_INSTANCES = 50 #a little faster but some instances not recognized
config = InferenceConfig()
config.display()
left = tf.placeholder(tf.float32,
[2, args.input_height, args.input_width, 3])
modeld = MonodepthModel(params, "test", left, None)
modelrcnn = modellib.MaskRCNN(mode="inference",
model_dir=MODEL_DIR,
config=config)
modelrcnn.load_weights(COCO_MODEL_PATH, by_name=True)
class_names = [
'BG', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
'train', 'truck', 'boat', 'traffic light', 'fire hydrant', 'stop sign',
'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep',
'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella',
'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard',
'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard',
'surfboard', 'tennis racket', 'bottle', 'wine glass', 'cup', 'fork',
'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange',
'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair',
'couch', 'potted plant', 'bed', 'dining table', 'toilet', 'tv',
'laptop', 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
'scissors', 'teddy bear', 'hair drier', 'toothbrush'
]
while True:
ret, frame = capture.read()
input_image = frame
original_height, original_width, num_channels = input_image.shape
input_image = scipy.misc.imresize(
input_image, [args.input_height, args.input_width],
interp='lanczos')
input_image = input_image.astype(np.float32) / 255
input_images = np.stack((input_image, np.fliplr(input_image)), 0)
# SESSION
config = tf.ConfigProto(allow_soft_placement=True)
sess = tf.Session(config=config)
# INIT
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
coordinator = tf.train.Coordinator()
disp = sess.run(modeld.disp_left_est[0],
feed_dict={left: input_images})
disp_pp = post_process_disparity(disp.squeeze()).astype(np.float32)
results = modelrcnn.detect([frame], verbose=0)
r = results[0]
disp_to_img = scipy.misc.imresize(disp_pp.squeeze(),
[original_height, original_width])
frame = display_instances(disp_to_img, r['rois'], r['masks'],
r['class_ids'], class_names, r['scores'])
cv2.imshow('frame', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
if __name__ == '__main__':
"""
test everything
"""
import os
import sys
import coco
import utils
import model as modellib
ROOT_DIR = os.getcwd()
MODEL_DIR = os.path.join(ROOT_DIR, "logs") #model stored dir
COCO_MODEL_PATH = os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(
COCO_MODEL_PATH) #if not exist download coco model
class InferenceConfig(coco.CocoConfig):
GPU_COUNT = 1
IMAGES_PER_GPU = 1
config = InferenceConfig()
config.display()
model = modellib.MaskRCNN( #model
mode="inference", model_dir=MODEL_DIR, config=config)
model.load_weights(
COCO_MODEL_PATH,
by_name=True) #using alredy pretrainedwweights on coco dataset
class_names = [
'BG', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
def person_blocker(args):
# Required to load model, but otherwise unused
ROOT_DIR = os.getcwd()
COCO_MODEL_PATH = args.model or os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
MODEL_DIR = os.path.join(ROOT_DIR, "logs") # Required to load model
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
# Load model and config
config = InferenceConfig()
model = modellib.MaskRCNN(mode="inference",
model_dir=MODEL_DIR,
config=config)
model.load_weights(COCO_MODEL_PATH, by_name=True)
image = imageio.imread(args.image)
# Create masks for all objects
results = model.detect([image], verbose=0)
r = results[0]
if args.labeled:
position_ids = [
'[{}]'.format(x) for x in range(r['class_ids'].shape[0])
]
visualize.display_instances(image, r['rois'],
r['masks'], r['class_ids'],
get_class_names(), position_ids)
sys.exit()
# Filter masks to only the selected objects
objects = np.array(args.objects)
# Object IDs:
if np.all(np.chararray.isnumeric(objects)):
object_indices = objects.astype(int)
# Types of objects:
else:
selected_class_ids = np.flatnonzero(np.in1d(get_class_names(),
objects))
object_indices = np.flatnonzero(
np.in1d(r['class_ids'], selected_class_ids))
mask_selected = np.sum(r['masks'][:, :, object_indices], axis=2)
# Replace object masks with noise
mask_color = string_to_rgb_triplet(args.color)
image_masked = image.copy()
noisy_color = create_noisy_color(image, mask_color)
image_masked[mask_selected > 0] = noisy_color[mask_selected > 0]
imageio.imwrite('person_blocked.png', image_masked)
# Create GIF. The noise will be random for each frame,
# which creates a "static" effect
images = [image_masked]
num_images = 10 # should be a divisor of 30
for _ in range(num_images - 1):
new_image = image.copy()
noisy_color = create_noisy_color(image, mask_color)
new_image[mask_selected > 0] = noisy_color[mask_selected > 0]
images.append(new_image)
imageio.mimsave('person_blocked.gif', images, fps=30., subrectangles=True)
def person_blocker(args):
# Required to load model, but otherwise unused
ROOT_DIR = os.getcwd()
COCO_MODEL_PATH = args.model or os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
MODEL_DIR = os.path.join(ROOT_DIR, "logs") # Required to load model
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
# Load model and config
config = InferenceConfig()
model = modellib.MaskRCNN(mode="inference",
model_dir=MODEL_DIR, config=config)
model.load_weights(COCO_MODEL_PATH, by_name=True)
print("[INFO] starting video stream...")
vs = VideoStream(src=0).start()
time.sleep(2.0)
fps = FPS().start()
while True:
frame = vs.read()
frame = imutils.resize(frame, width=1000)
image = imageio.imread(frame)
results = model.detect([image], verbose=0)
r = results[0]
# if args.labeled:
# position_ids = ['[{}]'.format(x)
# for x in range(r['class_ids'].shape[0])]
# visualize.display_instances(img, r['rois'],
# r['masks'], r['class_ids'],
# get_class_names(), position_ids)
# sys.exit()
# Filter masks to only the selected objects
objects = np.array(args.objects)
# Object IDs:
if np.all(np.chararray.isnumeric(objects)):
object_indices = objects.astype(int)
# Types of objects:
else:
selected_class_ids = np.flatnonzero(np.in1d(get_class_names(),
objects))
object_indices = np.flatnonzero(
np.in1d(r['class_ids'], selected_class_ids))
mask_selected = np.sum(r['masks'][:, :, object_indices], axis=2) if len(object_indices) > 0 else None
# Replace object masks with noise
# mask_color = string_to_rgb_triplet(args.color)
image_masked = img.copy()
# noisy_color = create_noisy_color(image, mask_color)
noisy_color = create_noisy_color(img, (208, 130, 238))
if mask_selected is not None:
image_masked[mask_selected > 0] = noisy_color[mask_selected > 0]
image_masked = imutils.resize(image_masked, width=1500)
cv2.imshow("Frame", image_masked)
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
break
update the FPS counter
fps.update()
fps.stop()
print("[INFO] elapsed time: {:.2f}".format(fps.elapsed()))
print("[INFO] approx. FPS: {:.2f}".format(fps.fps()))
do a bit of cleanup
cv2.destroyAllWindows()
vs.stop()
exit()
config.display()
# Create model
if args.command == "train":
model = modellib.MaskRCNN(mode="training", config=config,
model_dir=args.logs)
else:
model = modellib.MaskRCNN(mode="inference", config=config,
model_dir=args.logs)
# Select weights file to load
if args.weights.lower() == "coco":
weights_path = COCO_WEIGHTS_PATH
# Download weights file
if not os.path.exists(weights_path):
utils.download_trained_weights(weights_path)
elif args.weights.lower() == "last":
# Find last trained weights
weights_path = model.find_last()[1]
elif args.weights.lower() == "imagenet":
# Start from ImageNet trained weights
weights_path = model.get_imagenet_weights()
else:
weights_path = args.weights
# Load weights
print("Loading weights ", weights_path)
if args.weights.lower() == "coco":
# Exclude the last layers because they require a matching
# number of classes
model.load_weights(weights_path, by_name=True, exclude=[
def continueTrainingCoCo_kfold(epochs):
COCO_MODEL_PATH = os.path.join(ROOT_DIR, "model", "mask_rcnn_coco.h5")
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
train_fold = [0, 1]
for i in range(3):
if i not in train_fold:
print('skip fold', i)
continue
config = train_config()
if FULLDATA:
config.STEPS_PER_EPOCH = 10000
config.LEARNING_RATE = config.LEARNING_RATE / 4
config.NAME = '{}{}'.format(config.NAME, i)
config.display()
dataset = ShapesDataset(i, 0, -1)
dataset.load_imgs(TRAIN_PATH)
dataset.prepare()
#print("Image Count: {}".format(len(dataset.image_ids)))
#print("Class Count: {}".format(dataset.num_classes))
dataset_valid = ShapesDataset(i, 1, 1)
dataset_valid.load_imgs(VALID_PATH)
dataset_valid.prepare()
model = modellib.MaskRCNN(mode="training",
config=config,
model_dir=MODEL_DIR)
search_dir = os.path.join(MODEL_DIR, config.NAME)
if not os.path.exists(search_dir):
os.mkdir(search_dir)
print('search_dir', search_dir)
model_path = model.find_last(search_dir)[1]
if model_path:
print("Loading weights from " + model_path)
model.load_weights(model_path, by_name=True)
elif config.TRAIN_FROM_COCO == 1:
print('train from CoCo')
model.load_weights(COCO_MODEL_PATH,
by_name=True,
exclude=[
"mrcnn_class_logits", "mrcnn_bbox_fc",
"mrcnn_bbox", "mrcnn_mask"
])
else:
print('train from scrash')
print('start training', i)
model.train(dataset,
dataset_valid,
learning_rate=config.LEARNING_RATE * 2,
epochs=5,
layers="heads",
argument=config.ARGUMENT)
model_path = model.find_last(search_dir)[1]
print("Loading weights from " + model_path)
model.load_weights(model_path, by_name=True)
stage1_path = os.path.join(
model.log_dir, '{}_{}.h5'.format(config.NAME.lower(), 'heads'))
model_path = model.find_last(search_dir)[1]
if model_path:
print("Loading weights from " + model_path)
model.load_weights(model_path, by_name=True)
model.train(dataset,
dataset_valid,
learning_rate=config.LEARNING_RATE,
epochs=15,
layers="all",
argument=config.ARGUMENT)
model_path = model.find_last(search_dir)[1]
if model_path:
print("Loading weights from " + model_path)
model.load_weights(model_path, by_name=True)
model.train(dataset,
dataset_valid,
learning_rate=config.LEARNING_RATE / 10,
epochs=50,
layers="all",
argument=config.ARGUMENT)
from keras import backend as K
K.clear_session()
import cv2
import numpy as np
import os
import sys
import coco
import utils
import model as modellib
ROOT_DIR = os.getcwd()
MODEL_DIR = os.path.join(ROOT_DIR, "logs")
COCO_MODEL_PATH = os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
class InferenceConfig(coco.CocoConfig):
GPU_COUNT = 1
IMAGES_PER_GPU = 1
config = InferenceConfig()
config.display()
model = modellib.MaskRCNN(
mode="inference", model_dir=MODEL_DIR, config=config
)
model.load_weights(COCO_MODEL_PATH, by_name=True)
class_names = [
'BG', 'person', 'bicycle', 'car', 'motorcycle', 'airplane',
'bus', 'train', 'truck', 'boat', 'traffic light',
'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird',
def person_blocker(args):
# Required to load model, but otherwise unused
ROOT_DIR = os.getcwd()
COCO_MODEL_PATH = args.model or os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
MODEL_DIR = os.path.join(ROOT_DIR, "logs") # Required to load model
if not os.path.exists(COCO_MODEL_PATH):
utils.download_trained_weights(COCO_MODEL_PATH)
# Load model and config
config = InferenceConfig()
model = modellib.MaskRCNN(mode="inference",
model_dir=MODEL_DIR,
config=config)
model.load_weights(COCO_MODEL_PATH, by_name=True)
print("[INFO] starting video stream...")
url = f"http://*****:*****@140.193.201.45:8080/shot.jpg"
while True:
# Create masks for all objects
img_response = requests.get(url)
img_array = np.array(bytearray(img_response.content), dtype=np.uint8)
if img_array is not None:
img = cv2.imdecode(img_array, -1)
results = model.detect([img], verbose=0)
r = results[0]
# Filter masks to only the selected objects
objects = np.array(args.objects)
# Object IDs:
if np.all(np.chararray.isnumeric(objects)):
object_indices = objects.astype(int)
# Types of objects:
else:
selected_class_ids = np.flatnonzero(
np.in1d(get_class_names(), objects))
object_indices = np.flatnonzero(
np.in1d(r['class_ids'], selected_class_ids))
mask_selected = np.sum(r['masks'][:, :, object_indices],
axis=2) if len(object_indices) > 0 else None
# Replace object masks with noise
# mask_color = string_to_rgb_triplet(args.color)
image_masked = img.copy()
# noisy_color = create_noisy_color(image, mask_color)
noisy_color = create_noisy_color(img, (208, 130, 238))
if mask_selected is not None:
image_masked[mask_selected > 0] = noisy_color[mask_selected > 0]
image_masked = imutils.resize(image_masked, width=1500)
cv2.imshow("Frame", image_masked)
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
break
exit()
