def predict_for_submit(model):
"""Predict on the test set for final submission.
model: the model to test.
limit: the images to be used.
save: whether to save the masks.
"""
for i in range(args.limit, 70):
image = np.load(args.data + "image_test_np/liver_" + str(i) + ".npy").astype(np.float32) # [512, 512, D]
nib_image = nib.load(args.data + "imagesTs/test-volume-" + str(i) + ".nii.gz")
affine = nib_image.affine
ori_shape = nib_image.shape
start_time = time.time()
try:
result = model.detect([image])[0]
print("processing", i, "detect_time:", time.time() - start_time)
mask = result["mask"]
mask = resize(mask, ori_shape, order=0, preserve_range=True, anti_aliasing=False)
vol = nib.Nifti1Image(mask.astype(np.uint8), affine)
if not os.path.exists("./results/submissions/"):
os.makedirs("./results/submissions/")
nib.save(vol, "./results/submissions/test-segmentation-" + str(i) + ".nii")
except:
pass
print("prediction completed")
def main():
# Header & Page Config.
st.set_page_config(
page_title="Parth - Detr",
layout="centered")
st.title("Object Detection using DETR:")
# This will let you upload PNG, JPG & JPEG File
buffer = st.file_uploader("Upload your Image here", type = ["jpg", "png", "jpeg"])
if buffer:
# Object Detecting
with st.spinner('Wait for it...'):
# Slider for changing confidence
confidence = st.slider('Confidence Threshold', 0, 100, 90)
# Calculating time for detection
t1 = time.time()
im = Image.open(buffer)
im.save("saved_images/image.jpg")
res_img = detect("saved_images/image.jpg", confidence)
t2 = time.time()
# Displaying the image
st.image(res_img, use_column_width = True)
# Printing Time
st.write("\n")
st.write("Time taken: ", t2-t1, "sec.")
def load_object(file_name, model):
model = modellib.MaskRCNN(
mode="inference", model_dir=MODEL_DIR, config=config)
image = skimage.io.imread(file_name)
model = os.path.dirname
results = model.detect([image], verbose=1)
r = results[0]
# visualize.display_instances(image, r['rois'], r['masks'], r['class_ids'],
# class_names, r['scores'])
N = len(r['rois'])
colors = random_colors(N)
figsize = (16, 16)
_, ax = plt.subplots(1, figsize=figsize)
height, width = image.shape[:2]
ax.axis('off')
ax.margins(0, 0)
color = (.2, 0.5, 0.9)
captions = None
masked_image = image.astype(np.uint32).copy()
counts = {}
output = []
for i in range(N):
y1, x1, y2, x2 = r['rois'][i]
if not captions:
caption = class_names[r['class_ids'][i]]
if caption not in counts:
counts[caption] = 1
caption = caption+str(counts[caption])
else:
counts[caption] += 1
caption = caption+str(counts[caption])
else:
caption = captions[i]
ax.text(x1, y1 + 8, caption,
color='w', size=11, backgroundcolor="none")
output.append(caption)
mask = r['masks'][:, :, i]
masked_image = apply_mask(masked_image, mask, color)
padded_mask = np.zeros(
(mask.shape[0] + 2, mask.shape[1] + 2), dtype=np.uint8)
padded_mask[1:-1, 1:-1] = mask
contours = find_contours(padded_mask, 0.5)
for verts in contours:
verts = np.fliplr(verts) - 1
p = Polygon(verts, facecolor="none", edgecolor=color)
ax.add_patch(p)
# fig = ax.imshow(masked_image.astype(np.uint8))
# fig.axes.get_xaxis().set_visible(False)
# fig.axes.get_yaxis().set_visible(False)
ax.axes.get_xaxis().set_visible(False)
ax.axes.get_yaxis().set_visible(False)
plt.savefig('show.jpg', bbox_inches='tight',
pad_inches=0)
return r
def classify():
print('Starting...')
data = request.form
plant_type = data['plant_type']
# print(base64.b64decode(request.files['file'].read())[:10])
img = PILImage.create(base64.b64decode(request.files['file'].read()))
# import pdb; pdb.set_trace()
print('Detecting...')
diagnosis = detect(img, plant_type)
response = {'diagnosis': diagnosis}
return jsonify(response)
def run_model(n_clicks, n_submit, iou, confidence, checklist, url):
apply_nms = 'enabled' in checklist
try:
im = Image.open(requests.get(url, stream=True).raw)
except:
return go.Figure().update_layout(title='Incorrect URL')
tstart = time.time()
scores, boxes = detect(im, detr, transform, device=DEVICE)
scores, boxes = filter_boxes(scores,
boxes,
confidence=confidence,
iou=iou,
apply_nms=apply_nms)
scores = scores.data.numpy()
boxes = boxes.data.numpy()
tend = time.time()
fig = pil_to_fig(im,
showlegend=True,
title=f'DETR Predictions ({tend-tstart:.2f}s)')
existing_classes = set()
for i in range(boxes.shape[0]):
class_id = scores[i].argmax()
label = CLASSES[class_id]
confidence = scores[i].max()
x0, y0, x1, y1 = boxes[i]
# only display legend when it's not in the existing classes
showlegend = label not in existing_classes
text = f"class={label}<br>confidence={confidence:.3f}"
add_bbox(
fig,
x0,
y0,
x1,
y1,
opacity=0.7,
group=label,
name=label,
color=COLORS[class_id],
showlegend=showlegend,
text=text,
)
existing_classes.add(label)
return fig, not apply_nms
def __init__(self):
# create root window
self.main_window = tk.Tk()
self.main_window.pack_propagate(0)
self.main_window.geometry("500x700")
self.main_window.title("ECSU Protein Anomaly Labeling")
self.main_window.configure(bg="SlateGray3")
self.main_window.resizable(0, 0)
# create frames
self.font = Font(family='Times', size=24, weight="bold")
self.frame1 = tk.LabelFrame(self.main_window,
text="Inputs",
bg="SlateGray3",
fg="RoyalBlue3",
bd=5,
relief="groove",
font=self.font) # create frame 1
self.frame1.place(x=10, y=10, anchor="nw", height=80, width=480)
self.frame2 = tk.LabelFrame(self.main_window,
text="Sequence",
bg="SlateGray3",
fg="RoyalBlue3",
bd=5,
relief="groove",
font=self.font) # create frame 2
self.frame2.place(x=10, y=90, anchor="nw", height=200, width=480)
self.frame3 = tk.LabelFrame(self.main_window,
text="Labels",
bg="SlateGray3",
fg="RoyalBlue3",
bd=5,
relief="groove",
font=self.font) # create frame 3
self.frame3.place(x=10, y=290, anchor="nw", height=400, width=480)
# add components into frame1
self.label1 = tk.Label(self.frame1,
text="Chain",
relief="groove",
bg="SlateGray3",
fg="blue4",
font=Font(family="helvetica",
size=16,
weight="bold"))
self.label1.place(x=5, y=5, anchor="nw", height=30, width=80)
self.options = control.getChains()
#self.options = ["A", "B"]
self.variable = tk.StringVar(self.frame1)
self.variable.set(self.options[0])
self.menu = tk.OptionMenu(self.frame1, self.variable, *self.options)
self.menu.config(bg="SlateGray3")
self.menu.place(x=90, y=5, anchor="nw", height=30, width=100)
#self.menu.bind('<Activate>', self.choose_chain)
self.label2 = tk.Label(self.frame1,
text="Threshold",
relief="groove",
bg="SlateGray3",
fg="blue4",
font=Font(family="helvetica",
size=16,
weight="bold"))
self.label2.place(x=210, y=5, anchor="nw", height=30, width=120)
self.threhold = tk.StringVar(self.frame1, value='10')
self.entry = tk.Entry(self.frame1,
textvariable=self.threhold,
bd=1,
relief="flat",
justify="center",
bg="SlateGray3",
fg="blue4")
self.entry.config(highlightbackground="SlateGray3")
self.entry.place(x=340, y=5, height=30, width=50, anchor="nw")
self.button = tk.Button(self.frame1,
text="Check",
relief="groove",
bd=1,
bg="SlateGray3",
fg="blue4",
font=Font(family="helvetica",
size=16,
weight="bold"),
command=self.update)
self.button.place(x=390, y=10, anchor="nw")
# data
self.current_chain = self.variable.get()
self.current_threshold = float(self.entry.get())
self.mol_name = control.getMolName()
#print 'Molecule name:', self.mol_name
#print 'Threhold:', self.current_threshold
os.chdir(
os.path.dirname(os.path.realpath(__file__))
) # change the working directory, the default directory is root which is not writable
#print 'Working directory: ', os.path.dirname(os.path.realpath(__file__))
self.labels = model.detect(
self.mol_name,
self.current_threshold) # information of labeled residues
#print(self.labels)
# Chimera display
rc('color blue') # display whole molecule as blue
# add components into frame2
tk.mainloop()
def test(model, limit, save, bbox):
"""Test the model.
model: the model to test.
limit: the images to be used.
save: whether to save the masks.
limit: whether to draw the bboxes.
"""
per_class_ious = []
info = json.load(open(args.data + "dataset.json"))
info = list(info['train_and_test'])
detect_time = 0
for path in info[:limit]:
path_image = path['image']
path_label = path['label']
image = nib.load(path_image).get_data().copy()
label = nib.load(path_label) # load the gt-masks
affine = label.affine # prepared to save the predicted mask later
label = label.get_data().copy()
image = np.expand_dims(image, -1)
start_time = time.time()
result = model.detect([image])[0]
detect_time += time.time() - start_time
print("detect_time:", time.time() - start_time)
"""The shape of result: a dict containing
{
"rois": final_rois, [N, (y1, x1, z1, y2, x2, z2)] in real coordinates
"class_ids": final_class_ids, [N]
"scores": final_scores, [N]
"mask": final_mask, [mask_shape[0], mask_shape[1], mask_shape[2]]
}"""
rois = result["rois"]
class_ids = result["class_ids"]
scores = result["scores"]
mask = result["mask"]
# Prepare the gt-masks and pred-masks to calculate the ious.
gt_masks = np.zeros((image.shape[0], image.shape[1], image.shape[2],
model.config.NUM_CLASSES - 1))
pred_masks = np.zeros((image.shape[0], image.shape[1], image.shape[2],
model.config.NUM_CLASSES - 1))
# Generate the per instance gt masks.
for j in range(model.config.NUM_CLASSES - 1):
gt_masks[:, :, :, j][label == j + 1] = 1
# Generate the per instance predicted masks.
for j in range(model.config.NUM_CLASSES - 1):
pred_masks[:, :, :, j][mask == j + 1] = 1
# calculate different kind of ious
per_class_iou = utils.compute_per_class_mask_iou(gt_masks, pred_masks)
per_class_ious.append(per_class_iou)
# Save the results
if save == "true":
# Draw bboxes
if bbox == "true":
y1, x1, z1, y2, x2, z2 = rois[0, :]
mask[y1, x1:x2, z1] = 10
mask[y1, x1:x2, z2] = 10
mask[y2, x1:x2, z1] = 10
mask[y2, x1:x2, z2] = 10
mask[y1:y2, x1, z1] = 10
mask[y1:y2, x2, z1] = 10
mask[y1:y2, x1, z2] = 10
mask[y1:y2, x2, z2] = 10
mask[y1, x1, z1:z2] = 10
mask[y1, x2, z1:z2] = 10
mask[y2, x1, z1:z2] = 10
mask[y2, x2, z1:z2] = 10
vol = nib.Nifti1Image(mask.astype(np.int32), affine)
if not os.path.exists("./results"):
os.makedirs("./results")
nib.save(
vol, "./results/" + str(per_class_iou.mean()) + "_" +
path_image[-17:])
print(path_image[-17:] + " detected done. iou = " + str(per_class_iou))
print("Test completed.")
# Print the iou results.
per_class_ious = np.array(per_class_ious)
print("per class iou mean:", np.mean(per_class_ious, axis=0))
print("std:", np.std(per_class_ious, axis=0))
print("Total ious mean:", per_class_ious.mean())
print("Total detect time:", detect_time)
from Utils import Generate_Dataset,SplitPDF
from config import window_size,model_path
from model import build_model,detect
from Preprocessor import Preprocessor
import argparse
parser = argparse.ArgumentParser(description='Enter A file to detect its EOD')
parser.add_argument('PDF_Path')
args = parser.parse_args()
PDF_Path = args.PDF_Path
if __name__ == '__main__':
print("Loading and preprocessing the PDF file")
processor = Preprocessor(PDF_Path)
preprocessed = processor.Preprocess()
print("File successfully loaded and processed")
Generator = Generate_Dataset(preprocessed,window_size)
X_testCNN,X_testLSTM = Generator.generate()
print("Building the model")
MainModel = build_model()
EOD = detect(MainModel,model_path,X_testLSTM,X_testCNN)
print("Saving the splitted files")
splitter = SplitPDF(PDF_Path,EOD)
splitter.split()
def test_firearm_distance_close(self):
score = detect("")
self.assertTrue(score > threshold)
def test_firearm_indoor(self):
score = detect("")
self.assertTrue(score > threshold)
def test_firearm_outdoor_rain(self):
score = detect("")
self.assertTrue(score > threshold)
image_id, use_mini_mask=False)
log("original_image", original_image)
log("image_meta", image_meta)
log("gt_class_id", gt_class_id)
log("gt_bbox", gt_bbox)
log("gt_mask", gt_mask)
visualize.display_instances(original_image,
gt_bbox,
gt_mask,
gt_class_id,
dataset_train.class_names,
figsize=(8, 8))
results = model.detect([original_image], verbose=1)
r = results[0]
visualize.display_instances(original_image, r['rois'], r['masks'],
r['class_ids'], dataset_val.class_names,
r['scores'])
####################################################################
# EVALUATING THE MEAN AVERAGE PRECISION #
####################################################################
# Compute VOC-Style mAP @ IoU=0.5
# Running on 30 images. Increase for better accuracy.
def test(model):
"""Test the model."""
save_path = "./results/" + args.weights[27:] + "/"
if not os.path.exists(save_path):
os.makedirs(save_path)
per_class_ious = []
box_iou = []
detect_time = 0
for i in range(args.limit, 131):
image = np.load(args.data + "image_np/liver_" + str(i) + ".npy").astype(np.float32) # [H, W, D]
label = np.load(args.data + "label_np/liver_label_" + str(i) + ".npy").astype(np.int32) # [H, W, D, num_class]
gt_bbox = utils.extract_bboxes(label)
gt_bbox = utils.extend_bbox(gt_bbox, label.shape)
nib_label = nib.load("/media/disk1/LiTS/labelTr/segmentation-" + str(i) + ".nii.gz")
affine = nib_label.affine # prepared to save the predicted mask later
ori_shape = nib_label.shape
try:
start_time = time.time()
result = model.detect([image])[0]
detect_time += time.time() - start_time
print("detect_time:", time.time() - start_time)
"""The shape of result: a dict containing
{
"rois": final_rois, [N, (y1, x1, z1, y2, x2, z2)] in real coordinates
"class_ids": final_class_ids, [N]
"scores": final_scores, [N]
"mask": final_mask, [mask_shape[0], mask_shape[1], mask_shape[2]]
}"""
rois = result["rois"]
class_ids = result["class_ids"]
scores = result["scores"]
mask = result["mask"]
if args.stage == 'beginning':
mask = np.zeros(mask.shape).astype(np.int32)
rois = rois.clip(min=0)
rois[:, 3] = rois[:, 3].clip(max=mask.shape[0] - 1)
rois[:, 4] = rois[:, 4].clip(max=mask.shape[1] - 1)
rois[:, 5] = rois[:, 5].clip(max=mask.shape[2] - 1)
rois = rois.astype(np.int32)
# import pdb
# pdb.set_trace()
# compute bbox iou
print("gt_bbox:", gt_bbox, "pred_bbox:", rois)
box_iou.append(utils.compute_overlaps(np.array([gt_bbox]), rois)[0, 0])
if args.stage != 'beginning':
# Prepare the gt-masks and pred-masks to calculate the ious. [H, W, D, num_classes - 1]
gt_masks = np.zeros(label.shape[:3] + (model.config.NUM_CLASSES - 1,))
pred_masks = np.zeros(image.shape + (model.config.NUM_CLASSES - 1,))
for j in range(model.config.NUM_CLASSES - 1):
gt_masks[:, :, :, j][label == j + 1] = 1
pred_masks[:, :, :, j][mask == j + 1] = 1
# calculate different kind of ious
per_class_iou = utils.compute_per_class_mask_iou(gt_masks, pred_masks)
per_class_ious.append(per_class_iou)
# Save the results
if args.save:
# Draw bboxes
if args.bbox:
for j in range(rois.shape[0]):
y1, x1, z1, y2, x2, z2 = rois[j, :]
mask[y1:y2, x1:x2, z1:z2] = 100
mask = resize(mask, ori_shape, order=0, mode='constant', preserve_range=True, anti_aliasing=False)
vol = nib.Nifti1Image(mask.astype(np.uint8), affine)
if args.stage != 'beginning':
nib.save(vol, save_path + str(per_class_iou.mean()) + "_liver_" + str(i) + ".nii.gz")
print("liver_" + str(i) + " detected done. iou = " + str(per_class_iou))
else:
nib.save(vol, save_path + str(box_iou[-1]) + "_liver_" + str(i) + ".nii.gz")
print("liver_" + str(i) + " detected done. box_iou = " + str(box_iou[-1]))
except:
print("detect error!")
pass
print("Test completed.")
# Print the iou results.
box_iou = np.array(box_iou)
print("box iou:", box_iou)
print("mean:", box_iou.mean())
if args.stage != 'beginning':
per_class_ious = np.array(per_class_ious)
print("per class iou mean:", np.mean(per_class_ious, axis=0))
print("std:", np.std(per_class_ious, axis=0))
print("Total ious mean:", per_class_ious.mean())
print("Total detect time:", detect_time)
