def get_centroids(self):
centroids = np.array([0,0])
for idx,cnt in enumerate(self.contours):
# M = cv2.moments(cnt)
# cx = int(M['m10']/M['m00'])
# cy = int(M['m01']/M['m00'])
coords = np.array(polylabel(cnt))
centroids = np.vstack([centroids,coords])
centroids = centroids[1:]
return centroids
def _get_center_point_features(self, features):
center_points = []
for feature in features:
center_points.append({
'type':
'Point',
'geometry':
polylabel(feature['geometry'], precision=1.0),
'properties':
feature['properties']
})
return center_points
def main():
pts = create_points(10)
print("Points:", pts)
anchor, sorted_pts = graham_scan(pts)
hull = build_hull_list(anchor, sorted_pts)
centr = polylabel([hull], with_distance=True)
ani = FuncAnimation(fig,
animate,
frames=build_hull(anchor, sorted_pts),
fargs=(pts, centr),
interval=500,
repeat=False)
plt.show()
def load(self):
# Bound to loadButton
fileNames = filedialog.askopenfilenames(filetypes=[("All Data Files", ".csv .str .txt .arch_d"),
("CSV", ".csv"),
("STR", ".str"),
("Text", ".txt"),
("Vulcan Data", ".arch_d")])
if not fileNames:
return
polygons = []
for fileName in fileNames:
polygons.extend(parseData(fileName))
if not polygons:
return
circles = []
for polygon in polygons:
# TODO(Derek): polylabel sometimes infinite loops if bad data is given
# contained multiple polygons in one, with 0, 0 in between.
# circle is formatted as [[x,y,z],radius]
circle = list(polylabel(polygon[0], precision=0.001, with_distance=True))
if not circle[1]:
prettyPolygon = [[polygon[0][i][0], polygon[0][i][1], polygon[1][i]] for i in range(len(polygon[0]))]
messagebox.showerror(title="Error", message=f"Could not create circle from polygon:\n{prettyPolygon}")
return
circle[0].append(sum(polygon[1])/len(polygon[1]))
circles.append(circle)
self.polygons = polygons
self.circles = circles
self.numPolygons.set(len(polygons))
self.saveButton.state(["!disabled"])
self.drawShapes()
"""
Find good points for labels within each GeoJSON feature
Output is slighly different than centroids, see:
https://blog.mapbox.com/a-new-algorithm-for-finding-a-visual-center-of-a-polygon-7c77e6492fbc
"""
import numpy as np
import pandas as pd
import geopandas as gpd
from polylabel import polylabel
smd = gpd.read_file('smd.geojson')
label_points = pd.DataFrame(columns=['smd_id', 'lon', 'lat'])
for i, row in smd.iterrows():
district_outline = np.dstack(row.geometry.boundary[0].coords.xy).tolist()
[lon, lat] = polylabel(district_outline)
label_points.loc[i, 'smd_id'] = 'smd_' + row['SMD_ID']
label_points.loc[i, 'smd'] = row['SMD_ID']
label_points.loc[i, 'lon'] = lon
label_points.loc[i, 'lat'] = lat
label_points.sort_values(by='smd_id', inplace=True)
label_points.to_csv('label_points.csv', index=False)
def applyMask(
image_path,
mask_path,
save_path,
segmented_save_path,
mat_save,
threshold,
git_repo_base,
bregma_list,
atlas_to_brain_align,
model,
dlc_pts,
atlas_pts,
olfactory_check,
use_unet,
use_dlc,
plot_landmarks,
align_once,
atlas_label_list,
region_labels=True,
original_label=False,
):
"""
Use mask output from model to segment brain image into brain regions, and save various outputs.
:param image_path: path to folder where brain images are saved
:param mask_path: path to folder where masks are saved
:param save_path: path to overall folder for saving all images
:param segmented_save_path: path to overall folder for saving segmented/labelled brain images
:param mat_save: choose whether or not to output brain regions to .mat files
:param threshold: set threshold for segmentation of foregrounds
:param git_repo_base: The path to the base git repository containing necessary resources for MesoNet (reference
atlases, DeepLabCut config files, etc.)
:param bregma_list: The list of bregma locations (or landmarks closest to bregma).
:param region_labels: Choose whether or not to attempt to label each region with its name from the Allen Institute
Mouse Brain Atlas.
:param use_unet: Choose whether or not to define the borders of the cortex using a U-net model.
:param atlas_to_brain_align: If True, registers the atlas to each brain image. If False, registers each brain image
to the atlas.
:param model: The name of the U-net model (for passthrough to mask_functions.py)
:param dlc_pts: The landmarks for brain-atlas registration as determined by the DeepLabCut model.
:param atlas_pts: The landmarks for brain-atlas registration from the original brain atlas.
:param olfactory_check: If True, draws olfactory bulb contours on the brain image.
:param plot_landmarks: If True, plots DeepLabCut landmarks (large circles) and original alignment landmarks (small
circles) on final brain image.
:param atlas_label_list: A list of aligned atlases in which each brain region is filled with a unique numeric label.
This allows for consistent identification of brain regions across images. If original_label is True, this is an
empty list.
:param align_once: If True, carries out all alignments based on the alignment of the first atlas and brain. This can
save time if you have many frames of the same brain with a fixed camera position.
:param region_labels: choose whether to assign a name to each region based on an existing brain atlas (not currently
implemented).
:param original_label: If True, uses a brain region labelling approach that attempts to automatically sort brain
regions in a consistent order (left to right by hemisphere, then top to bottom for vertically aligned regions). This
approach may be more flexible if you're using a custom brain atlas (i.e. not one in which each region is filled with
a unique number).
"""
tif_list = glob.glob(os.path.join(image_path, "*tif"))
if atlas_to_brain_align:
if use_dlc and align_once:
image_name_arr = glob.glob(
os.path.join(mask_path, "*_brain_warp.png"))
else:
image_name_arr = glob.glob(os.path.join(image_path, "*.png"))
image_name_arr.sort(key=natural_sort_key)
if tif_list:
tif_stack = imageio.mimread(os.path.join(image_path, tif_list[0]))
image_name_arr = tif_stack
else:
# FOR ALIGNING BRAIN TO ATLAS
image_name_arr = glob.glob(os.path.join(mask_path, "*_brain_warp.png"))
image_name_arr.sort(key=natural_sort_key)
region_bgr_lower = (220, 220, 220)
region_bgr_upper = (255, 255, 255)
base_c_max = []
count = 0
# Find the contours of an existing set of brain regions (to be used to identify each new brain region by shape)
mat_files = glob.glob(
os.path.join(git_repo_base, "atlases/mat_contour_base/*.mat"))
mat_files.sort(key=natural_sort_key)
# adapt. from https://stackoverflow.com/questions/3016283/create-a-color-generator-from-given-colormap-in-matplotlib
cm = pylab.get_cmap("viridis")
colors = [cm(1.0 * i / NUM_COLORS)[0:3] for i in range(NUM_COLORS)]
colors = [
tuple(color_idx * 255 for color_idx in color_t) for color_t in colors
]
for file in mat_files:
mat = scipy.io.loadmat(
os.path.join(git_repo_base, "atlases/mat_contour_base/", file))
mat = mat["vect"]
ret, thresh = cv2.threshold(mat, 5, 255, cv2.THRESH_BINARY)
base_c = cv2.findContours(thresh, cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
base_c = imutils.grab_contours(base_c)
base_c_max.append(max(base_c, key=cv2.contourArea))
if not atlas_to_brain_align and use_unet:
# FOR ALIGNING ATLAS TO BRAIN
num_images = len(glob.glob(os.path.join(mask_path, "*_brain_warp*")))
output = os.path.join(mask_path, "..")
from mesonet.predict_regions import predictRegion
mask_generate = True
tif_list = glob.glob(os.path.join(image_path, "*tif"))
if tif_list:
input_path = image_path
else:
input_path = mask_path
predictRegion(
input_path,
num_images,
model,
output,
mat_save,
threshold,
mask_generate,
git_repo_base,
atlas_to_brain_align,
dlc_pts,
atlas_pts,
olfactory_check,
use_unet,
plot_landmarks,
align_once,
atlas_label_list,
region_labels,
original_label,
)
for i, item in enumerate(image_name_arr):
label_num = 0
if not atlas_to_brain_align:
atlas_path = os.path.join(mask_path, "{}_atlas.png".format(str(i)))
mask_input_path = os.path.join(mask_path, "{}.png".format(i))
mask_warped_path = os.path.join(
mask_path, "{}_mask_warped.png".format(str(i)))
atlas_to_mask(atlas_path, mask_input_path, mask_warped_path,
mask_path, i, use_unet, atlas_to_brain_align,
git_repo_base, olfactory_check, [])
new_data = []
if len(tif_list) != 0 and atlas_to_brain_align:
img = item
img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB)
else:
img = cv2.imread(item)
if atlas_to_brain_align:
img = cv2.resize(img, (512, 512))
if use_dlc:
bregma_x, bregma_y = bregma_list[i]
else:
bregma_x, bregma_y = [
round(img.shape[0] / 2),
round(img.shape[1] / 2)
]
original_label = True
mask = cv2.imread(os.path.join(mask_path, "{}.png".format(i)))
mask = cv2.resize(mask, (img.shape[0], img.shape[1]))
# Get the region of the mask that is white
mask_color = cv2.inRange(mask, region_bgr_lower, region_bgr_upper)
io.imsave(os.path.join(save_path, "{}_mask_binary.png".format(i)),
mask_color)
# Marker labelling
# noise removal
kernel = np.ones((3, 3), np.uint8) # 3, 3
mask_color = np.uint8(mask_color)
thresh_atlas, atlas_bw = cv2.threshold(mask_color, 128, 255, 0)
# if atlas_to_brain_align and use_dlc:
# atlas_bw = cv2.dilate(atlas_bw, kernel, iterations=1) # 1
# io.imsave(os.path.join(save_path, "{}_atlas_binary.png".format(i)), atlas_bw)
if not atlas_to_brain_align:
watershed_run_rule = i == 0
else:
if len(tif_list) == 0:
watershed_run_rule = True
else:
watershed_run_rule = i == 0
if align_once:
watershed_run_rule = i == 0
labels_from_region = []
if watershed_run_rule:
orig_list = []
orig_list_labels = []
orig_list_labels_left = []
orig_list_labels_right = []
# unique_regions = (np.unique(atlas_label)).tolist()
# unique_regions = [e for e in unique_regions if e.is_integer()]
unique_regions = [
-275,
-268,
-255,
-249,
-164,
-150,
-143,
-136,
-129,
-98,
-78,
-71,
-64,
-57,
-50,
-43,
-36,
-29,
-21,
-15,
0,
15,
21,
29,
36,
43,
50,
57,
64,
71,
78,
98,
129,
136,
143,
150,
164,
249,
255,
268,
275,
300,
400,
]
# atlas_label_df = pd.DataFrame(atlas_label)
# atlas_label_df.to_csv(os.path.join(save_path, "atlas_label.csv"))
cnts_orig = []
# Find contours in original aligned atlas
if atlas_to_brain_align and not original_label:
np.savetxt(
"atlas_label_list_{}.csv".format(i),
atlas_label_list[i],
delimiter=",",
)
for region_idx in unique_regions:
if region_idx in [300, 400]:
# workaround to address olfactory contours not being found
region = cv2.inRange(atlas_label_list[i],
region_idx - 5, region_idx + 5)
cnt_for_idx, hierarchy = cv2.findContours(
region.copy(), cv2.RETR_TREE,
cv2.CHAIN_APPROX_NONE)[-2:]
if len(cnt_for_idx) >= 1:
cnt_for_idx = cnt_for_idx[0]
else:
region = cv2.inRange(atlas_label_list[i], region_idx,
region_idx)
cnt_for_idx = cv2.findContours(region.copy(),
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
cnt_for_idx = imutils.grab_contours(cnt_for_idx)
if len(cnt_for_idx) >= 1:
cnt_for_idx = max(cnt_for_idx, key=cv2.contourArea)
if len(cnt_for_idx) >= 1:
cnts_orig.append(cnt_for_idx)
labels_from_region.append(region_idx)
else:
cnts_orig = cv2.findContours(atlas_bw.copy(),
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
cnts_orig = imutils.grab_contours(cnts_orig)
if not use_dlc:
# cnts_orig = cv2.findContours(
# atlas_bw.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE
#)
cnts_orig, hierarchy = cv2.findContours(
atlas_bw.copy(), cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)[-2:]
# cnts_orig = imutils.grab_contours(cnts_orig)
labels_cnts = []
for (num_label, cnt_orig) in enumerate(cnts_orig):
labels_cnts.append(cnt_orig)
try:
cv2.drawContours(img, cnt_orig, -1, (255, 0, 0), 1)
# io.imsave(os.path.join(segmented_save_path, "check_contour.png"), img)
except:
print("Could not draw contour!")
# try:
if atlas_to_brain_align:
c_orig_as_list = cnt_orig.tolist()
c_orig_as_list = [[c_val[0] for c_val in c_orig_as_list]]
else:
c_orig_as_list = cnt_orig.tolist()
c_orig_as_list = [[c_val[0] for c_val in c_orig_as_list]]
orig_polylabel = polylabel(c_orig_as_list)
orig_x, orig_y = int(orig_polylabel[0]), int(orig_polylabel[1])
if not original_label and atlas_to_brain_align:
label_to_use = unique_regions.index(
labels_from_region[num_label])
(text_width,
text_height) = cv2.getTextSize(str(label_to_use),
cv2.FONT_HERSHEY_SIMPLEX,
0.4,
thickness=1)[0]
label_jitter = 0
label_color = (0, 0, 255)
cv2.rectangle(
img,
(orig_x + label_jitter, orig_y + label_jitter),
(
orig_x + label_jitter + text_width,
orig_y + label_jitter - text_height,
),
(255, 255, 255),
cv2.FILLED,
)
cv2.putText(
img,
str(label_to_use),
(int(orig_x + label_jitter),
int(orig_y + label_jitter)),
cv2.FONT_HERSHEY_SIMPLEX,
0.4,
label_color,
1,
)
label_num += 1
orig_list.append((orig_x, orig_y))
orig_list_labels.append((orig_x - bregma_x, orig_y - bregma_y,
orig_x, orig_y, num_label))
if (orig_x - bregma_x) < 0:
orig_list_labels_left.append((
orig_x - bregma_x,
orig_y - bregma_y,
orig_x,
orig_y,
num_label,
))
elif (orig_x - bregma_x) > 0:
orig_list_labels_right.append((
orig_x - bregma_x,
orig_y - bregma_y,
orig_x,
orig_y,
num_label,
))
orig_list.sort()
orig_list_labels_sorted_left = sorted(orig_list_labels_left,
key=lambda t: t[0],
reverse=True)
orig_list_labels_sorted_right = sorted(orig_list_labels_right,
key=lambda t: t[0])
flatten = lambda l: [obj for sublist in l for obj in sublist]
orig_list_labels_sorted = flatten(
[orig_list_labels_sorted_left, orig_list_labels_sorted_right])
vertical_check = np.asarray(
[val[0] for val in orig_list_labels_sorted])
for (orig_coord_val,
orig_coord) in enumerate(orig_list_labels_sorted):
vertical_close = np.where(
(abs(vertical_check - orig_coord[0]) <= 5))
vertical_close_slice = vertical_close[0]
vertical_matches = np.asarray(
orig_list_labels_sorted)[vertical_close_slice]
if len(vertical_close_slice) > 1:
vertical_match_sorted = sorted(vertical_matches,
key=lambda t: t[1])
orig_list_labels_sorted_np = np.asarray(
orig_list_labels_sorted)
orig_list_labels_sorted_np[
vertical_close_slice] = vertical_match_sorted
orig_list_labels_sorted = orig_list_labels_sorted_np.tolist(
)
img = np.uint8(img)
else:
for num_label, cnt_orig in enumerate(cnts_orig): # cnts_orig
try:
cv2.drawContours(img, cnt_orig, -1, (255, 0, 0), 1)
except:
print("Could not draw contour!")
if not atlas_to_brain_align and use_unet:
cortex_mask = cv2.imread(
os.path.join(mask_path, "{}_mask.png".format(i)))
cortex_mask = cv2.cvtColor(cortex_mask, cv2.COLOR_RGB2GRAY)
thresh, cortex_mask_thresh = cv2.threshold(cortex_mask, 128, 255,
0)
cortex_cnt = cv2.findContours(cortex_mask_thresh,
cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
cortex_cnt = imutils.grab_contours(cortex_cnt)
cv2.drawContours(img, cortex_cnt, -1, (0, 0, 255), 3)
labels_x = []
labels_y = []
areas = []
sorted_labels_arr = []
label_jitter = 0
mask = np.zeros(mask_color.shape, dtype="uint8")
cnts = cnts_orig
print("LEN CNTS: {}".format(len(cnts)))
print("LEN LABELS: {}".format(len(orig_list_labels_sorted)))
if original_label or not atlas_to_brain_align:
labels_from_region = [0] * len(orig_list_labels_sorted)
for (z, cnt), (coord_idx, coord), label_from_region in zip(
enumerate(cnts), enumerate(orig_list_labels_sorted),
labels_from_region):
if atlas_to_brain_align and not original_label:
coord_label_num = unique_regions.index(
labels_from_region[coord_idx])
else:
coord_label_num = coord_idx
# compute the center of the contour
if len(cnts) > 1:
z = 0
c_x, c_y = int(coord[2]), int(coord[3])
c = cnt
if not atlas_to_brain_align and use_unet:
cnt_loc_label = ("inside" if [1.0] in [
list(
set([
cv2.pointPolygonTest(
cortex_sub_cnt,
(
c_coord.tolist()[0][0],
c_coord.tolist()[0][1],
),
False,
) for c_coord in c
])) for cortex_sub_cnt in cortex_cnt
] else "outside")
else:
cnt_loc_label = ""
rel_x = c_x - bregma_x
rel_y = c_y - bregma_y
pt_inside_cnt = [
coord_check for coord_check in orig_list_labels_sorted
if cv2.pointPolygonTest(c, (int(coord_check[2]),
int(coord_check[3])), False) == 1
]
if original_label:
try:
pt_inside_cnt_idx = orig_list_labels_sorted.index(
pt_inside_cnt[0])
label_for_mat = pt_inside_cnt_idx
except:
label_for_mat = coord_label_num
print(
"WARNING: label was not found in region. Order of labels may be incorrect!"
)
else:
label_for_mat = coord_label_num
# if cnt_loc_label != '':
# coord_label_num = "{} {}".format(coord_label_num, cnt_loc_label)
# The centroid of the contour works as the contour centre in most cases. However, sometimes the
# centroid is outside of the contour. As such, using the average x and y positions of the contour edges
# that intersect with the centroid could be a safer option. We try to find this average position and if
# there are more than two intersecting edges or if the average position is over 200 px from the
# centroid, we fall back to using the centroid as our measure of the centre of the contour.
# for coord in c_for_centre:
# if coord[0][0] == c_x:
# edge_coords_y.append(coord[0].tolist())
# if coord[0][1] == c_y:
# edge_coords_x.append(coord[0].tolist())
# print("{}: edge coords x: {}, edge coords y: {}".format(label, edge_coords_x, edge_coords_y))
# adj_centre_x = int(np.mean([edge_coords_x[0][0], edge_coords_x[-1][0]]))
# adj_centre_y = int(np.mean([edge_coords_y[0][1], edge_coords_y[-1][1]]))
# adj_centre = [adj_centre_x, adj_centre_y]
# if abs(adj_centre_x - c_x) <= 100 and abs(adj_centre_x - c_y) <= 100:
# print("adjusted centre: {}, {}".format(adj_centre[0], adj_centre[1]))
# c_x, c_y = (adj_centre[0], adj_centre[1])
# edge_coords_x = []
# edge_coords_y = []
# compute center relative to bregma
# rel_x = contour centre x coordinate - bregma x coordinate
# rel_y = contour centre y coordinate - bregma y coordinate
# print("Contour {}: centre ({}, {}), bregma ({}, {})".format(label, rel_x, rel_y, bregma_x, bregma_y))
c_rel_centre = [rel_x, rel_y]
if not os.path.isdir(
os.path.join(segmented_save_path, "mat_contour_centre")):
os.mkdir(
os.path.join(segmented_save_path, "mat_contour_centre"))
# If .mat save checkbox checked in GUI, save contour paths and centre to .mat files for each contour
if mat_save:
mat_save = True
else:
mat_save = False
# Prepares lists of the contours identified in the brain image, in the order that they are found by
# OpenCV
# labels_arr.append(label)
sorted_labels_arr.append(coord_label_num)
labels_x.append(int(c_x))
labels_y.append(int(c_y))
areas.append(cv2.contourArea(c))
# The first contour just outlines the entire image (which does not provide a useful label or .mat
# contour) so we'll ignore it
# if coord_label_num != 0:
# Cross-references each contour with a set of contours from a base brain atlas that was manually
# labelled with brain regions (as defined in 'region_labels.csv' in the 'atlases' folder). If the
# area of the contour is within 5000 square px of the original region and the centre of the contour
# is at most 100 px away from the centre of the original contour, label the contour with its
# corresponding brain region. Until we figure out how to consistently and accurately label small
# brain regions, we only label brain regions with an area greater than 1000 square px.
shape_list = []
label_color = (0, 0, 255)
for n_bc, bc in enumerate(base_c_max):
shape_compare = cv2.matchShapes(c, bc, 1, 0.0)
shape_list.append(shape_compare)
# for (n_r, r), (n_bc, bc) in zip(enumerate(regions.itertuples()), enumerate(base_c_max)):
# min_bc = list(bc[0][0])
# min_c = list(c[0][0])
# max_bc = list(bc[0][-1])
# max_c = list(c[0][-1])
#
# # 0.3, 75
# if label_num == 0 and region_labels and \
# (min(shape_list) - 0.3 <= cv2.matchShapes(c, bc, 1, 0.0) <= min(shape_list) + 0.3) and \
# min_bc[0] - 75 <= min_c[0] <= min_bc[0] + 75 and \
# min_bc[1] - 75 <= min_c[1] <= min_bc[1] + 75 and \
# max_bc[0] - 75 <= max_c[0] <= max_bc[0] + 75 and \
# max_bc[1] - 75 <= max_c[1] <= max_bc[1] + 75:
# # print("Current contour top left corner: {},{}".format(min_c[0], min_c[1]))
# # print("Baseline contour top left corner: {},{}".format(min_bc[0], min_bc[1]))
# closest_label = r.name
# cv2.putText(img, "{} ({})".format(closest_label, r.Index),
# (int(c_x + label_jitter), int(c_y + label_jitter)),
# cv2.FONT_HERSHEY_SIMPLEX, 0.3, label_color, 1)
# label_num += 1
# if label_num == 0 and not region_labels:
if (not region_labels
and original_label) or (not region_labels
and not atlas_to_brain_align):
(text_width,
text_height) = cv2.getTextSize(str(coord_label_num),
cv2.FONT_HERSHEY_SIMPLEX,
0.4,
thickness=1)[0]
cv2.rectangle(
img,
(c_x + label_jitter, c_y + label_jitter),
(c_x + label_jitter + text_width,
c_y + label_jitter - text_height),
(255, 255, 255),
cv2.FILLED,
)
cv2.putText(
img,
str(coord_label_num),
(int(c_x + label_jitter), int(c_y + label_jitter)),
cv2.FONT_HERSHEY_SIMPLEX,
0.4,
label_color,
1,
)
label_num += 1
if mat_save:
# Create an empty array of the same size as the contour, with the centre of the contour
# marked as "255"
c_total = np.zeros_like(mask)
c_centre = np.zeros_like(mask)
# Follow the path of the contour, setting every pixel along the path to 255
# Fill in the contour area with 1s
cv2.fillPoly(c_total, pts=[c], color=(255, 255, 255))
# Set the contour's centroid to 255
if c_x < mask.shape[0] and c_y < mask.shape[0]:
c_centre[c_x, c_y] = 255
if not os.path.isdir(
os.path.join(segmented_save_path, "mat_contour")):
os.mkdir(os.path.join(segmented_save_path, "mat_contour"))
if not os.path.isdir(
os.path.join(segmented_save_path,
"mat_contour_centre")):
os.mkdir(
os.path.join(segmented_save_path,
"mat_contour_centre"))
sio.savemat(
os.path.join(
segmented_save_path,
"mat_contour/roi_{}_{}_{}_{}.mat".format(
cnt_loc_label, i, label_for_mat, z),
),
{
"roi_{}_{}_{}_{}".format(cnt_loc_label, i, label_for_mat, z):
c_total
},
appendmat=False,
)
sio.savemat(
os.path.join(
segmented_save_path,
"mat_contour_centre/roi_centre_{}_{}_{}_{}.mat".format(
cnt_loc_label, i, label_for_mat, z),
),
{
"roi_centre_{}_{}_{}_{}".format(
cnt_loc_label, i, label_for_mat, z):
c_centre
},
appendmat=False,
)
sio.savemat(
os.path.join(
segmented_save_path,
"mat_contour_centre/rel_roi_centre_{}_{}_{}_{}.mat".
format(cnt_loc_label, i, label_for_mat, z),
),
{
"rel_roi_centre_{}_{}_{}_{}".format(
cnt_loc_label, i, label_for_mat, z):
c_rel_centre
},
appendmat=False,
)
count += 1
if align_once:
idx_to_use = 0
else:
idx_to_use = i
if plot_landmarks:
for pt, color in zip(dlc_pts[idx_to_use], colors):
cv2.circle(img, (int(pt[0]), int(pt[1])), 10, color, -1)
for pt, color in zip(atlas_pts[idx_to_use], colors):
cv2.circle(img, (int(pt[0]), int(pt[1])), 5, color, -1)
io.imsave(
os.path.join(segmented_save_path,
"{}_mask_segmented.png".format(i)), img)
img_edited = Image.open(
os.path.join(save_path, "{}_mask_binary.png".format(i)))
# Generates a transparent version of the brain atlas.
img_rgba = img_edited.convert("RGBA")
data = img_rgba.getdata()
for pixel in data:
if pixel[0] == 255 and pixel[1] == 255 and pixel[2] == 255:
new_data.append((pixel[0], pixel[1], pixel[2], 0))
else:
new_data.append(pixel)
img_rgba.putdata(new_data)
img_rgba.save(
os.path.join(save_path, "{}_mask_transparent.png".format(i)))
img_transparent = cv2.imread(
os.path.join(save_path, "{}_mask_transparent.png".format(i)))
img_trans_for_mat = np.uint8(img_transparent)
if mat_save:
sio.savemat(
os.path.join(segmented_save_path,
"mat_contour/transparent_{}".format(i)),
{"transparent_{}".format(i): img_trans_for_mat},
)
masked_img = cv2.bitwise_and(img, img_transparent, mask=mask_color)
if plot_landmarks:
for pt, color in zip(dlc_pts[idx_to_use], colors):
cv2.circle(masked_img, (int(pt[0]), int(pt[1])), 10, color, -1)
for pt, color in zip(atlas_pts[idx_to_use], colors):
cv2.circle(masked_img, (int(pt[0]), int(pt[1])), 5, color, -1)
io.imsave(os.path.join(save_path, "{}_overlay.png".format(i)),
masked_img)
print("Mask {} saved!".format(i))
d = {
"sorted_label": sorted_labels_arr,
"x": labels_x,
"y": labels_y,
"area": areas,
}
df = pd.DataFrame(data=d)
if not os.path.isdir(os.path.join(segmented_save_path,
"region_labels")):
os.mkdir(os.path.join(segmented_save_path, "region_labels"))
df.to_csv(
os.path.join(segmented_save_path, "region_labels",
"{}_region_labels.csv".format(i)))
print("Analysis complete! Check the outputs in the folders of {}.".format(
save_path))
k.clear_session()
if dlc_pts:
os.chdir("../..")
else:
os.chdir(os.path.join(save_path, '..'))
# In[21]:
connections = []
for i in range(len(graph.edges)):
connections.append(len(np.where(graph.edges[:, i] != np.inf)[0]))
connections = np.asarray(connections)
# In[22]:
from polylabel import polylabel
# ## Select the route starts
# In[23]:
center = polylabel([stop_coords])
distances = getDistance2(center, stop_coords)
radius = max(distances)
#bearings = np.random.randint(0,360, size=40)
bearings = [x for x in range(0, 365, 5)]
starts = [destinationPoint(center, radius, bearing) for bearing in bearings]
indexes = [getDistance_fast(start, stop_coords).argmin() for start in starts]
indexes = np.unique(indexes)
max_index = indexes[distances[indexes].argmax()]
# In[24]:
start_index = []
for start in starts:
index = getDistance_fast(start, stop_coords).argmin()
start_index.append(index)
def test_distance(self):
with open(cd + "/fixtures/short.json", "r") as f:
short = json.load(f)
self.assertEqual(polylabel(short, with_distance=True),
([3317.546875, 1330.796875], 5.4406249999999545))
def test_degenerate_polygons():
p = polylabel.polylabel([[[0, 0], [1, 0], [2, 0], [0, 0]]])
assert p == [0, 0]
p = polylabel.polylabel([[[0, 0], [1, 0], [1, 1], [1, 0], [0, 0]]])
assert p == [0, 0]
def test_watter2(self):
water2 = json.load(open("./fixtures/water2.json", "r"))
self.assertEquals(polylabel(water2, 1), [3263.5, 3263.5])
def test_works_on_degenerate_polygons(self):
out = polylabel([[[0, 0], [1, 0], [2, 0], [0, 0]]])
self.assertEquals(out, [0, 0])
out = polylabel([[[0, 0], [1, 0], [1, 1], [1, 0], [0, 0]]])
self.assertEquals(out, [0, 0])
def test_watter1(self):
water1 = json.load(open("./fixtures/water1.json", "r"))
self.assertEquals(polylabel(water1),
[3865.85009765625, 2124.87841796875])
self.assertEquals(polylabel(water1, 50), [3854.296875, 2123.828125])
def test_issue_no5(self):
self.assertEqual(
polylabel([[[100, 0], [105, 0], [110, 10], [100, 1], [100, 0]]]),
[103.125, 1.875])
def test_watter2(self):
with open(cd + "/fixtures/water2.json", "r") as f:
water2 = json.load(f)
self.assertEqual(polylabel(water2, 1), [3263.5, 3263.5])
def test_float(self):
with open(cd + "/fixtures/float.json", "r") as f:
float_poly = json.load(f)
self.assertEqual(polylabel(float_poly),
[-23.210525613080737, 24.425270860193958])
def test_poi_for_water1_and_precision_50():
p = polylabel.polylabel(water1, 50.0)
assert p == [3854.296875, 2123.828125]
def test_poi_for_water2_and_precision_1():
p = polylabel.polylabel(water2, 1.0)
assert p == [3263.5, 3263.5]
def test_short(self):
short = json.load(open("./fixtures/short.json", "r"))
self.assertEquals(polylabel(short), [3317.546875, 1330.796875])
def test_poi_for_water1_and_precision_1():
p = polylabel.polylabel(water1, 1.0)
assert p == [3865.85009765625, 2124.87841796875]
def test_short(self):
with open(cd + "/fixtures/short.json", "r") as f:
short = json.load(f)
self.assertEqual(polylabel(short), [3317.546875, 1330.796875])
