def get_nuc_cyto_ratios(db_imgs, marker_imgs, cyto_size, params):
"""
Take nuclear-stained images, calculate the region props to find each cell nucleus,
then dilate around each nucleus to find the cytoplasmic area. Map this back onto the
original image and record the ratio of the average intensities of each area.
:param db_images: DeepBlue images for segmentation etc.
:param cyto_size:
:param params: dict for segmentation params
:return:
"""
nuc_cyto_ratios = []
for i in range(len(db_imgs)):
print(i, 'out of ', len(db_imgs))
seg_img = segment_image(db_imgs[i], params)
regions = regionprops(seg_img)
for region in regions:
# create blank matrix to hold each nuclear region in the image
nuc = np.zeros(seg_img.shape)
nuc[list(region.coords.T)] = 1
# dilate to get cytoplasmic area
kernel = np.ones((5, 5), np.uint8)
cyto = cv2.dilate(nuc, kernel, iterations=cyto_size)
# get ratios
avg_cyto = np.mean(marker_imgs[i][cyto])
avg_nuc = np.mean(marker_imgs[i][nuc])
nuc_cyto_ratios.append(avg_nuc / avg_cyto)
return nuc_cyto_ratios
def translate_page(img,
binary_threshold=defaults.BINARY_THRESHOLD,
boxes=False,
target_lang="en"):
gray = clean.grayscale(img)
inv_binary = cv2.bitwise_not(
clean.binarize(gray, threshold=binary_threshold))
binary = clean.binarize(gray, threshold=binary_threshold)
segmented_image = seg.segment_image(gray)
segmented_image = segmented_image[:, :, 2]
components = get_connected_components(segmented_image)
for component in components:
speech = img[component]
if speech.shape[0] <= 0 or speech.shape[1] <= 0:
continue
translation = helper.ocr(speech, target_lang)
if len(translation) > 0:
#print "added component", translation
white_out_text(img, component)
add_text(img, component, translation)
if boxes:
cc.draw_bounding_boxes(img, components, color=(255, 0, 0), line_size=2)
return img
def main(image_name):
image = cv2.imread(image_name)
total_pieces, method, type = extract_parameters(image_name, image)
all_array = segment_image(image, total_pieces, method, type)
# print_array(all_array)
border_types = search_borders(all_array)
array_c, array_e, array_m, array_c_types, array_e_types, array_m_types = sort_images(
all_array, border_types)
print("containers with borders")
# print_array(array_c)
print(array_c_types)
print("--------")
# print_array(array_e)
print(array_e_types)
print("----------")
# print_array(array_m)
print(array_m_types)
print("----------")
result_array = solve_puzzle(total_pieces, method, array_c, array_e,
array_m, array_c_types, array_e_types,
array_m_types)
# print_array(result_array)
length, width = get_smallest_shape_scrambled(result_array)
final_image = show_puzzle(total_pieces, length, width, result_array)
return final_image
def optimize_params(img, params, epochs):
for i in range(epochs):
for key in params.keys():
if key != 'smallest_object':
keys = []
params[key] *= 1.01
keys.append(params[key])
seg_img = segment_image(img, params)
params[key] *= .99
keys.append(params[key])
seg_img2 = segment_image(img, params)
counts = [np.max(seg_img), np.max(seg_img2)]
params[key] = keys[counts.index(max(counts))]
print(i, max(counts))
print(params)
plt.imshow(seg_img2)
plt.show()
def segment(indir, outdir, extension):
'''
Segment the kernels in the image or images
params
* indir: directory with images to segment
* outdir: directory to output images (will create if doesn't exist)
* type: gray or rgb
'''
sp.run(['mkdir', '-p', outdir])
PATTERN = get_image_regex_pattern()
for image_path in os.listdir(indir):
if not PATTERN.match(image_path): continue
try:
image = imread(osp.join(indir, image_path))
seg_image = segment_image(image)
out_fname = create_name_from_path(image_path, out_dir=outdir)
imsave(out_fname, seg_image)
except Exception as e:
log.error('Failed to process ' + osp.basename(image_path))
log.error(e)
tb.print_exc()
continue
def populate_annotations():
vgg = _cache_model(variables["model_path"])
"""
TODO
1. for each row in charts table
2. get the image
3. update x, y, height, width columns in annotations table
"""
df = gdata.filter(variables["COARSE_LABELS"], table="charts")
for _, row in df.iterrows():
x = imread(BytesIO(row["image"].split(",")[1]))
pred, mask = seg.segment_image(x,
vgg,
blocksize=(224, 224),
plot=False)
rp = regionprops(mask.astype(int))
mask = mask.astype(bool)
labeled = label(mask)
rp = regionprops(labeled)
for region in rp:
minrow, mincol, maxrow, maxcol = region.bbox
"""
if not os.path.isfile(infile):
print(
'Please provide a regular existing input file. Use -h option for help.'
)
sys.exit(-1)
img = cv2.imread(infile)
gray = clean.grayscale(img)
binary_threshold = arg.integer_value(
'binary_threshold', default_value=defaults.BINARY_THRESHOLD)
if arg.boolean_value('verbose'):
print('Binarizing with threshold value of ' + str(binary_threshold))
inv_binary = cv2.bitwise_not(
clean.binarize(gray, threshold=binary_threshold))
binary = clean.binarize(gray, threshold=binary_threshold)
segmented_image = seg.segment_image(gray)
segmented_image = segmented_image[:, :, 2]
components = cc.get_connected_components(segmented_image)
cc.draw_bounding_boxes(img, components, color=(255, 0, 0), line_size=2)
imsave(outfile, img)
if arg.boolean_value('display'):
cv2.imshow('segmented_image', segmented_image)
if cv2.waitKey(0) == 27:
cv2.destroyAllWindows()
cv2.destroyAllWindows()
def dataset(indir, outdir, anno_file, validation_split, segment):
'''
Generate a dataset for CNN training
params
* indir: directory of preprocessed images
* outdir: directory to output the images to
* anno_file: the path to the file of annotations
'''
sp.run(['mkdir', '-p', outdir])
fh = logging.FileHandler(osp.join(outdir, 'log'))
fh.setLevel(logging.WARNING)
log.addHandler(fh)
data = osp.join(outdir, 'data')
sp.run(['mkdir', '-p', data])
sp.run(['mkdir', '-p', osp.join(data, 'train')])
# sp.run(['mkdir', '-p', osp.join(data, 'valid')]) # handled by split_val
for i in range(1, 6):
sp.run(['mkdir', '-p', osp.join(data, 'train', str(i))])
bbox_dir = osp.join(outdir, 'bboxes')
bbox_err_dir = osp.join(outdir, 'err_bboxes')
sp.run(['mkdir', '-p', bbox_dir])
sp.run(['mkdir', '-p', bbox_err_dir])
sp.run([
'echo', 'filename,rating\n', '>',
osp.join(outdir, 'annotations.csv')
])
bbox_err_count = 0
try:
annotations = pd.read_csv(anno_file)
# convert the ratings string to list
annotations['ratings'] = annotations['ratings'].apply(eval)
except FileNotFoundError as fnfe:
log.error(fnfe)
exit()
annotation_file = open(osp.join(outdir, 'annotations.csv'), 'a')
annotation_file.write("filename,rating\n")
annotations_summary = {'1': 0, '2': 0, '3': 0, '4': 0, '5': 0}
for i, row in annotations.iterrows():
log.info("Processing " + row['filename'])
image_path = osp.join(indir, row['filename'])
if not osp.isfile(image_path):
log.error("Could not locate " + str(image_path))
continue
try:
image = imread(image_path)
if is_gray(image):
image = gray2rgb(image)
except Exception as e:
log.error("Failed to load " + image_path)
log.error(e)
tb.print_exc()
continue
bboxes = get_sorted_bboxes(image)
plot_bbx(image, bboxes)
if len(bboxes) != row['num_objects']:
log.error("Count of objects in image did not match: " +
row['filename'])
out_fname = osp.join(bbox_err_dir, row['filename'])
bbox_err_count += 1
plt.savefig(out_fname)
plt.close('all')
continue
else:
out_fname = osp.join(bbox_dir, row['filename'])
plt.savefig(out_fname)
plt.close('all')
# squash 2d list to 1d
ratings = [entry for line in row['ratings'] for entry in line]
if segment:
image = segment_image(image)
log.info("Getting thumbnails")
for j, bbox in enumerate(bboxes):
anno = ratings[j]
minr, minc, maxr, maxc = bbox
thumbnail = image[minr:maxr, minc:maxc]
out_fname = osp.join(outdir, 'data', 'train', str(anno),
str(j) + "_" + row['filename'])
imsave(out_fname, thumbnail)
annotation_file.write("{},{}\n".format(
str(j) + "_" + row['filename'], anno))
annotations_summary[anno] += 1
annotation_file.close()
log.info("Generating validation dataset")
split_val(data, validation_split)
log.info("SUMMARY:")
log.info("Number of bbox errors: " + str(bbox_err_count))
for i in range(1, 6):
log.info("Number of annotations with rating {}: {}".format(
i, annotations_summary[str(i)]))
num_samples = sum(list(annotations_summary.values()))
log.info("Total number of images: {}".format(num_samples))
return
binary_threshold = arg.integer_value('binary_threshold', default_value=defaults.BINARY_THRESHOLD)
if arg.boolean_value('verbose'):
print 'Binarizing with threshold value of ' + str(binary_threshold)
inv_binary = cv2.bitwise_not(clean.binarize(gray, threshold=binary_threshold))
#cv2.imshow('inv_binary', inv_binary)
binary = clean.binarize(gray, threshold=binary_threshold)
#cv2.imshow('binary', binary)
segmented_image = seg.segment_image(gray)
cv2.imshow('segmented_image', segmented_image)
segmented_image = segmented_image[:,:,2]
components = cc.get_connected_components(segmented_image)
cc.draw_bounding_boxes(img,components,color=(255,0,0),line_size=2)
outfile = 'img/no_equalizeHist.png'
#imsave(outfile, img)
cv2.imshow('result',img)
#cv2.imshow('segmented_image',segmented_image)
if len(approx) == 4 :
mask = np.zeros([width, height, 3], dtype = "uint8")
mask_gray = cv2.cvtColor(mask,cv2.COLOR_BGR2GRAY)
cv2.drawContours(mask_gray,[cnt],0,(255,255,255),cv2.FILLED)
mask_gray_white = cv2.bitwise_not(mask_gray)
masked_img = cv2.bitwise_and(borderWhite, mask_gray, mask)
masked_img = cv2.bitwise_or(mask_gray_white, masked_img)
x,y,w,h = cv2.boundingRect(cnt)
crop_img = masked_img[y:y+h, x:x+w]
binary_threshold=arg.integer_value('binary_threshold',default_value=defaults.BINARY_THRESHOLD)
if arg.boolean_value('verbose'):
print ('Binarizing with threshold value of ' + str(binary_threshold))
inv_binary = cv2.bitwise_not(clean.binarize(crop_img, threshold=binary_threshold))
binary = clean.binarize(crop_img, threshold=binary_threshold)
segmented_image = seg.segment_image(crop_img)
segmented_image = segmented_image[:,:,2]
mySceneImage = np.copy(segmented_image)
image, contours, hierarchy = cv2.findContours(mySceneImage,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
for cnt in contours:
if cv2.contourArea(cnt) > 3000 :
cv2.drawContours(crop_img,[cnt],0,(255,255,255),cv2.FILLED)
#cv2.imshow('image',crop_img)
#cv2.waitKey(0)
#cv2.imwrite(pathSolved+"/"+str(counter)+".jpg", crop_img)
edges = cv2.Canny(crop_img,500,500)
edgesContours = cv2.findContours(edges,cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
CannyLines.append(len(edgesContours[1]))
widths.append(w)
heights.append(h)
AreaToRectangleRatio.append(cv2.contourArea(cnt)/(w*h))
# coding: utf-8
from skimage.measure import regionprops
from tensorflow.keras.models import load_model
from skimage.io import imread
from skimage.measure import label
import segmentation as seg
import matplotlib.pyplot as plt
vgg = load_model('vgg16-validated-five-classes.h5')
x = imread('/tmp/medistrava.png')
pred, mask = seg.segment_image(
x, vgg, blocksize=(224, 224), plot=True,
prob_threshold=0.66, prob_alpha=0.5, cmap=plt.cm.viridis)
rp = regionprops(mask.astype(int))
mask = mask.astype(bool)
labeled = label(mask)
rp = regionprops(labeled)
for region in rp:
minrow, mincol, maxrow, maxcol = region.bbox
plt.hlines(minrow, mincol, maxcol)
plt.hlines(maxrow, mincol, maxcol)
plt.vlines(mincol, minrow, maxrow)
plt.vlines(maxcol, minrow, maxrow)
plt.show()
