def run():
image = io.imread(cfg.imagePath, as_grey=True)
image_pyramid = pyramid_gaussian.get_pyramid(image)
for img in image_pyramid[::-1]:
cfg.num_of_patches = cfg.num_test_patches
patches, centres = sample_patches.create_patches_randomly(img)
F = extract_features.extractFeaturesForPatches(patches)
landmark_detection.run()
def run(imagepath):
t0 = time()
image = io.imread(imagepath, as_gray=True)
pyramid = pyramid_gaussian.get_pyramid(image)
cfg.num_of_patches = cfg.num_test_patches # changing the number of patches
for img, sc_name in zip(pyramid, cfg.scale_names):
if sc_name == '0_12':
init_flag = True
ss = []
ns = 0
patches, centres = sample_patches.create_patches_randomly(
img, subshape=ss, initialization=init_flag)
f = extract_features.extractFeaturesForPatches(patches)
# 0: femur
# 1: cadera
# 2: superior
# 3: inferior
d_tilde, f_tilde, c_tilde = build_matrices(cfg.bone_structures[3],
sc_name,
n_subs=ns)
l = d_tilde.shape[0] // 2 # number of landmarks
# Obtener los puntos
f_hat = np.concatenate((f_tilde, f), axis=1)
c_bar = compute_C_matrix(centres, l)
c = np.tile(centres, (l, 1))
d = compute_D_matrix(f_hat, d_tilde, c_bar, l)
data = d + c
kde_ = KernelDensity(kernel='gaussian', bandwidth=0.2).fit(data.T)
sc = kde_.score_samples(data.T)
max = np.argmax(np.exp(sc))
shape = data[:, max]
shape = np.reshape(shape, (l, 2))
a = shape[:, 0]
b = shape[:, 1]
a *= 8
b *= 8
# fig, ax_ = plt.subplots()
# ax_.imshow(image, cmap=plt.cm.gray)
# ax_.plot(a, b, 'r.', markersize=8, mec='k', mew=0.3)
# ax_.plot(a[5], b[5], 'b.', markersize=8, mec='k', mew=0.3)
# ax_.plot(a[12], b[12], 'b.', markersize=8, mec='k', mew=0.3)
# ax_.axis('off')
# plt.show()
a /= 4
b /= 4
else:
for count in range(5):
init_flag = False
if count == 4:
ss = shape[(4 * count):(4 * count + 5), :]
else:
ss = shape[(4 * count):(4 * count + 4), :]
ns = count
# if sc_name != '0_25':
# ss = shape[0:4,:]
patches, centres = sample_patches.create_patches_randomly(
img, subshape=ss, initialization=init_flag)
f = extract_features.extractFeaturesForPatches(patches)
# 0: femur
# 1: cadera
# 2: superior
# 3: inferior
d_tilde, f_tilde, c_tilde = build_matrices(
cfg.bone_structures[3], sc_name, n_subs=ns)
l = d_tilde.shape[0] // 2 # number of landmarks
# Obtener los puntos
f_hat = np.concatenate((f_tilde, f), axis=1)
c_bar = compute_C_matrix(centres, l)
c = np.tile(centres, (l, 1))
d = compute_D_matrix(f_hat, d_tilde, c_bar, l)
data = d + c
kde_ = KernelDensity(kernel='gaussian',
bandwidth=0.2).fit(data.T)
sc = kde_.score_samples(data.T)
max = np.argmax(np.exp(sc))
shape1 = data[:, max]
shape1 = np.reshape(shape1, (l, 2))
# a = shape1[:, 0]
# b = shape1[:, 1]
# if sc_name == '0_25':
# a *= 4
# b *= 4
# elif sc_name == '0_5':
# a *= 2
# b *= 2
# fig, ax_ = plt.subplots()
# ax_.imshow(image, cmap=plt.cm.gray)
# ax_.plot(a, b, 'r.', markersize=8, mec='k', mew=0.3)
# ax_.axis('off')
# plt.show()
# if sc_name == '0_25':
# a /= 2
# b /= 2
if count == 4:
shape[(4 * count):(4 * count + 5), :] = shape1[0:5, :] * 2
else:
shape[(4 * count):(4 * count + 4), :] = shape1[0:4, :] * 2
a = shape[:, 0]
b = shape[:, 1]
if sc_name == '0_25':
a = a * 2
b = b * 2
if sc_name == '1':
a = a / 2
b = b / 2
# fig, ax_ = plt.subplots()
# ax_.imshow(image, cmap=plt.cm.gray)
# ax_.plot(a, b, 'r.', markersize=8, mec='k', mew=0.3)
# ax_.plot(a[5], b[5], 'b.', markersize=8, mec='k', mew=0.3)
# ax_.plot(a[12], b[12], 'b.', markersize=8, mec='k', mew=0.3)
# ax_.axis('off')
# plt.show()
izquierdaX = np.copy(a)
izquierdaY = np.copy(b)
for img, sc_name in zip(pyramid, cfg.scale_names):
if sc_name == '0_12':
init_flag = True
ss = []
ns = 0
patches, centres = sample_patches.create_patches_randomly(
img, subshape=ss, initialization=init_flag)
f = extract_features.extractFeaturesForPatches(patches)
# 0: femur
# 1: cadera
# 2: superior
# 3: inferior
d_tilde, f_tilde, c_tilde = build_matrices(cfg.bone_structures[1],
sc_name,
n_subs=ns)
l = d_tilde.shape[0] // 2 # number of landmarks
# Obtener los puntos
f_hat = np.concatenate((f_tilde, f), axis=1)
c_bar = compute_C_matrix(centres, l)
c = np.tile(centres, (l, 1))
d = compute_D_matrix(f_hat, d_tilde, c_bar, l)
data = d + c
kde_ = KernelDensity(kernel='gaussian', bandwidth=0.2).fit(data.T)
sc = kde_.score_samples(data.T)
max = np.argmax(np.exp(sc))
shape = data[:, max]
shape = np.reshape(shape, (l, 2))
a = shape[:, 0]
b = shape[:, 1]
a *= 8
b *= 8
# fig, ax_ = plt.subplots()
# ax_.imshow(image, cmap=plt.cm.gray)
# ax_.plot(a, b, 'r.', markersize=8, mec='k', mew=0.3)
# ax_.plot(a[5], b[5], 'b.', markersize=8, mec='k', mew=0.3)
# ax_.axis('off')
# plt.show()
a /= 4
b /= 4
else:
for count in range(5):
init_flag = False
if count == 4:
ss = shape[(4 * count):(4 * count + 5), :]
else:
ss = shape[(4 * count):(4 * count + 4), :]
ns = count
# if sc_name != '0_25':
# ss = shape[0:4,:]
patches, centres = sample_patches.create_patches_randomly(
img, subshape=ss, initialization=init_flag)
f = extract_features.extractFeaturesForPatches(patches)
# 0: femur
# 1: cadera
# 2: superior
# 3: inferior
d_tilde, f_tilde, c_tilde = build_matrices(
cfg.bone_structures[1], sc_name, n_subs=ns)
l = d_tilde.shape[0] // 2 # number of landmarks
# Obtener los puntos
f_hat = np.concatenate((f_tilde, f), axis=1)
c_bar = compute_C_matrix(centres, l)
c = np.tile(centres, (l, 1))
d = compute_D_matrix(f_hat, d_tilde, c_bar, l)
data = d + c
kde_ = KernelDensity(kernel='gaussian',
bandwidth=0.2).fit(data.T)
sc = kde_.score_samples(data.T)
max = np.argmax(np.exp(sc))
shape1 = data[:, max]
shape1 = np.reshape(shape1, (l, 2))
# a = shape1[:, 0]
# b = shape1[:, 1]
# if sc_name == '0_25':
# a *= 4
# b *= 4
# elif sc_name == '0_5':
# a *= 2
# b *= 2
# fig, ax_ = plt.subplots()
# ax_.imshow(image, cmap=plt.cm.gray)
# ax_.plot(a, b, 'r.', markersize=8, mec='k', mew=0.3)
# ax_.axis('off')
# plt.show()
# if sc_name == '0_25':
# a /= 2
# b /= 2
if count == 4:
shape[(4 * count):(4 * count + 5), :] = shape1[0:5, :] * 2
else:
shape[(4 * count):(4 * count + 4), :] = shape1[0:4, :] * 2
a = shape[:, 0]
b = shape[:, 1]
if sc_name == '0_25':
a = a * 2
b = b * 2
if sc_name == '1':
a = a / 2
b = b / 2
# fig, ax_ = plt.subplots()
# ax_.imshow(image, cmap=plt.cm.gray)
# ax_.plot(a, b, 'r.', markersize=8, mec='k', mew=0.3)
# ax_.plot(a[5], b[5], 'b.', markersize=8, mec='k', mew=0.3)
# ax_.plot(a[12], b[12], 'b.', markersize=8, mec='k', mew=0.3)
# ax_.axis('off')
# plt.show()
derechaX = np.copy(a)
derechaY = np.copy(b)
fig, ax_ = plt.subplots()
ax_.imshow(image, cmap=plt.cm.gray)
ax_.plot(a, b, 'r.', markersize=5, mec='k', mew=0.3)
ax_.plot(izquierdaX, izquierdaY, 'r.', markersize=8, mec='k', mew=0.3)
ax_.plot(derechaX, derechaY, 'r.', markersize=8, mec='k', mew=0.3)
IT = (izquierdaY[12] - izquierdaY[5]) / (izquierdaX[12] - izquierdaX[5])
DT = (derechaY[12] - derechaY[5]) / (derechaX[12] - derechaX[5])
a1 = 2 * izquierdaX[5] - izquierdaX[12]
a2 = 2 * izquierdaX[12] - izquierdaX[5]
b1 = IT * (a1 - izquierdaX[5]) + izquierdaY[5]
b2 = IT * (a2 - izquierdaX[5]) + izquierdaY[5]
c1 = 2 * derechaX[5] - derechaX[12]
c2 = 2 * derechaX[12] - derechaX[5]
d1 = DT * (c1 - derechaX[5]) + derechaY[5]
d2 = DT * (c2 - derechaX[5]) + derechaY[5]
HT = (derechaY[12] - izquierdaY[12]) / (derechaX[12] - izquierdaX[12])
e1 = a1
e2 = c1
f1 = HT * (e1 - izquierdaX[12]) + izquierdaY[12]
f2 = HT * (e2 - izquierdaX[12]) + izquierdaY[12]
g1 = izquierdaX[5]
g2 = HT * (g1 - izquierdaX[12]) + izquierdaY[12]
h1 = derechaX[5]
h2 = HT * (h1 - izquierdaX[12]) + izquierdaY[12]
ax_.plot([e1, e2], [f1, f2], 'g', markersize=8, mec='k', mew=0.3)
ax_.plot([c1, c2], [d1, d2], 'g', markersize=8, mec='k', mew=0.3)
ax_.plot([a1, a2], [b1, b2], 'g', markersize=8, mec='k', mew=0.3)
ax_.plot(izquierdaX[5],
izquierdaY[5],
'b.',
markersize=10,
mec='k',
mew=0.3)
ax_.plot(izquierdaX[12],
izquierdaY[12],
'b.',
markersize=10,
mec='k',
mew=0.3)
ax_.plot(derechaX[5], derechaY[5], 'b.', markersize=10, mec='k', mew=0.3)
ax_.plot(derechaX[12], derechaY[12], 'b.', markersize=10, mec='k', mew=0.3)
ax_.plot([g1, h1], [g2, h2], 'b.', markersize=10, mec='k', mew=0.3)
nume1 = izquierdaY[5] * (izquierdaX[12] - g1) + izquierdaY[12] * (
g1 - izquierdaX[5]) + g2 * (izquierdaX[5] - izquierdaX[12])
deno1 = (izquierdaX[5] - izquierdaX[12]) * (izquierdaX[12] - g1) + (
izquierdaY[5] - izquierdaY[12]) * (izquierdaY[12] - g2)
rati1 = nume1 / deno1
angl1 = math.atan(rati1)
deg1 = (angl1 * 180) / math.pi
if deg1 < 0:
deg1 = deg1 + 180
print(deg1)
nume2 = derechaY[5] * (derechaX[12] - h1) + derechaY[12] * (
h1 - derechaX[5]) + h2 * (derechaX[5] - derechaX[12])
deno2 = (derechaX[5] - derechaX[12]) * (derechaX[12] - h1) + (
derechaY[5] - derechaY[12]) * (derechaY[12] - h2)
rati2 = nume2 / deno2
angl2 = math.atan(rati2)
deg2 = (angl2 * 180) / math.pi
if deg2 < 0:
deg2 = deg2 + 180
deg2 = 180 - deg2
print(deg2)
ax_.text(izquierdaX[12] - 20,
izquierdaY[12] + 20,
round(deg1, 2),
color='yellow')
ax_.text(derechaX[12] + 20,
derechaY[12] + 20,
round(deg2, 2),
color='yellow')
print('####\tNiña\tNiño')
na = 'N'
no = 'N'
#1-2
if deg1 > 36 or deg2 > 36:
na = 'L'
if deg1 > 41.5 or deg2 > 41.5:
na = 'G'
if deg1 > 29 or deg2 > 31:
no = 'L'
if deg1 > 33 or deg2 > 35:
no = 'G'
print('1-2\t' + na + '\t' + no)
#3-4
if deg1 > 31.5 or deg2 > 33:
na = 'L'
if deg1 > 36.5 or deg2 > 38.5:
na = 'G'
if deg1 > 28 or deg2 > 29:
no = 'L'
if deg1 > 32.5 or deg2 > 33.5:
no = 'G'
print('3-4\t' + na + '\t' + no)
#5-6
if deg1 > 27.5 or deg2 > 29.5:
na = 'L'
if deg1 > 32 or deg2 > 34:
na = 'G'
if deg1 > 24.5 or deg2 > 27:
no = 'L'
if deg1 > 29 or deg2 > 31.5:
no = 'G'
print('5-6\t' + na + '\t' + no)
#7-9
if deg1 > 25.5 or deg2 > 27:
na = 'L'
if deg1 > 29.5 or deg2 > 31.5:
na = 'G'
if deg1 > 24.5 or deg2 > 25.5:
no = 'L'
if deg1 > 29 or deg2 > 29.5:
no = 'G'
print('7-9\t' + na + '\t' + no)
#2a-3a
if deg1 > 22 or deg2 > 23.5:
na = 'L'
if deg1 > 25.5 or deg2 > 27:
na = 'G'
if deg1 > 21 or deg2 > 22.5:
no = 'L'
if deg1 > 25 or deg2 > 27:
no = 'G'
print('2a-3a\t' + na + '\t' + no)
#3a-5a
if deg1 > 18 or deg2 > 21:
na = 'L'
if deg1 > 25.5 or deg2 > 25.5:
na = 'G'
if deg1 > 19 or deg2 > 20:
no = 'L'
if deg1 > 23.5 or deg2 > 24:
no = 'G'
print('3a-5a\t' + na + '\t' + no)
ax_.axis('off')
plt.show()
'''
l = d_tilde.shape[0] // 2 # number of landmarks
# Composed matrix
f_hat = np.concatenate((f_tilde, f), axis=1)
c_bar = compute_C_matrix(centres, l)
c = np.tile(centres, (l, 1))
d = compute_D_matrix(f_hat, d_tilde, c_bar, l)
positions_ = d + c
density_estimation(positions_, img,imagepath)
'''
'''
def run(bones, gt=False):
image = io.imread(cfg.imagePath, as_gray=True)
images_pyramid = pyramid_gaussian.get_pyramid(image)
sigma_values = np.array(cfg.sigma_values)
patch_sizes = cfg.testing_patch_sizes
print('Testing Image ...', cfg.imagePath)
f = os.path.basename(cfg.imagePath)
fn, ext = os.path.splitext(f)
cfg.resultsFolderPath = os.path.join(cfg.resultsFolderPath, fn)
subshapes = None
cfg.num_of_patches = cfg.num_test_patches # Modificar el numero de parches a muestrear
final_shapes = []
gt_shapes = []
bones_name = '_'.join(bones)
# Segmentation for each bone (femur, pelvis)
for bone in bones:
times = []
for img, sc_name, s, patch_size, idx_sc in zip(
images_pyramid, cfg.scale_names, sigma_values, patch_sizes,
range(len(cfg.scale_names))):
print('Testing Scale ', sc_name)
subshapes_ = []
if sc_name == cfg.init_scale:
init_flag = True
start = time.time()
landmarks = landmark_detection.get_estimated_landmarks(
bone, img, sc_name, init_flag=init_flag)
end = time.time()
times.append(end - start)
# added
plot_segmented_shape(img, landmarks, sc_name, bone)
subshapes = [
landmarks[x:x + cfg.subs_len]
for x in range(0, len(landmarks), cfg.subs_len)
]
# avoid subshapes of 1 landmark
if len(subshapes[-1]) == 1:
lmrk = subshapes.pop()
subshapes[-1] = np.vstack((subshapes[-1], lmrk))
subshapes = np.array(
subshapes) * cfg.downScaleFactor # upsample landmarks
continue
# Sequential Process
"""
inicio = time.time()
for n_sub, subs in enumerate(subshapes):
print('Detecting Landmarks in Subshape', str(n_sub))
landmarks = landmark_detection.get_estimated_landmarks(bone, img, sc_name, subs, n_sub)
subshapes_.append(landmarks)
fin = time.time()
print('TIEMPO', fin - inicio)
"""
# Parallel Process
l = len(subshapes)
print('LEN SUBSHAPES', l)
num_cores = multiprocessing.cpu_count()
# n = len(os.sched_getaffinity(0))
pool = multiprocessing.Pool(processes=num_cores)
try:
start = time.time()
subshapes_ = pool.starmap(
landmark_detection.get_estimated_landmarks,
zip(repeat(bone), repeat(img), repeat(sc_name), subshapes,
range(l)))
finally:
pool.close()
pool.join()
end = time.time()
times.append(end - start)
subshapes = np.array(subshapes_)
shape = np.vstack(subshapes) # Updated shape
# added
plot_segmented_shape(img, shape, sc_name, bone)
# ASM
print('Computing Active Shape Model...')
start = time.time()
shape = active_shape_model.run(bone, shape, sc_name)
end = time.time()
times.append(end - start)
plot_segmented_shape(img, shape, sc_name, bone, refined=True)
# GRADIENT PROFILING
if sc_name != cfg.scale_names[-1]:
print('Computing Gradient Profiling...')
start = time.time()
shape = gradient_profiling.run(bone, img, s, patch_size, shape,
sc_name, idx_sc)
end = time.time()
times.append(end - start)
if sc_name == cfg.scale_names[-1]:
final_shapes.append(shape)
if gt:
# leer el json y comparar
f = os.path.basename(cfg.imagePath)
fn, ext = os.path.splitext(f)
json = os.path.join(cfg.path_json, fn + '.json')
shapes_gt = json_reader.get_all_landmarks_(json)
shape_gt = shapes_gt[cfg.bone_structures.index(bone)]
# shape_gt /= 2
gt_shapes.append(shape_gt)
x, y = shape_gt.T
plt.plot(x,
y,
'g|-',
ms=1.8,
lw=0.5,
label='Gold Standard')
plot_segmented_shape(img, shape, sc_name, bone, gt=True)
# Metrics
metrics.compute_segmentation_metrics(
shape_gt, shape, image, bone)
subshapes = [
shape[x:x + cfg.subs_len]
for x in range(0, len(shape), cfg.subs_len)
]
# avoid subshapes of 1 landmark
if len(subshapes[-1]) == 1:
lmrk = subshapes.pop()
subshapes[-1] = np.vstack((subshapes[-1], lmrk))
subshapes = np.array(subshapes)
subshapes *= cfg.downScaleFactor
# Save the computation time
header = 'Computation Time for {}\n'.format(bone)
header += 'Landmark Detection Initial Scale, Landmark Detection, ASM, Gradient Profiling for other scales (25%,50%,100%)'
metrics.save_computation_time(times, header, bone)
# Final segmentation
plt.imshow(image, cmap=plt.cm.gray)
final_shapes = np.array(final_shapes)
for sh in final_shapes:
x, y = sh.T
plt.plot(x, y, 'o-', ms=2, mec='k', mew=0.3)
plt.axis('off')
output_path = cfg.resultsFolderPath
plt.savefig(output_path + '/final_segmentation_' + bones_name + '_.' +
cfg.img_format,
format=cfg.img_format,
bbox_inches='tight',
pad_inches=0,
dpi=cfg.dpi)
plt.close()
# JSW
if len(final_shapes) % 2 == 0: # this must be modified
seg_distances = calculate_jsw(image, final_shapes, bones_name)
if gt:
gt_shapes = np.array(gt_shapes)
gt_distances = calculate_jsw(image, gt_shapes, bones_name, gt=True)
# Error Rates
metrics.compute_jsw_error_rates(gt_distances, seg_distances,
bones_name)
def run():
images_list = os.listdir(cfg.datasetRoot)
images_list = filter(lambda element: '.JPG' in element, images_list)
dataset_images = os.listdir(cfg.datasetRoot)
dataset_images = filter(lambda element: '.JPG' in element, dataset_images)
count = len(list(dataset_images))
print('Training', count, 'X-Ray Images')
femur_shape = np.array([(141.33333333333334, 610.6666666666666),
(148.0, 604.0),
(155.33333333333334, 598.6666666666666),
(163.33333333333334, 592.0),
(169.33333333333334, 584.0),
(172.66666666666666, 575.3333333333334),
(174.66666666666666, 566.6666666666666),
(173.5, 556.5), (168.66666666666666, 548.0),
(165.33333333333334, 540.0), (168.0, 533.0),
(172.0, 527.5), (176.0, 521.5), (181.5, 515.5),
(186.5, 509.5), (190.5, 504.0), (196.5, 499.5),
(202.5, 495.0), (209.0, 492.0), (219.0, 493.5),
(231.0, 495.0), (244.0, 495.5), (254.0, 489.0),
(262.5, 480.0), (268.5, 471.5), (274.0, 462.5),
(275.5, 451.0), (275.5, 438.0), (274.0, 418.5),
(273.0, 406.5), (267.5, 396.5), (259.5, 387.5),
(249.0, 381.0), (238.0, 376.5), (226.0, 373.5),
(214.0, 372.5), (200.5, 374.5), (187.5, 378.5),
(176.5, 384.0), (166.0, 392.5), (160.0, 402.5),
(155.5, 414.0), (149.5, 422.5), (138.5, 425.0),
(126.0, 425.0), (115.5, 424.5), (105.5, 420.0),
(99.5, 414.0), (91.5, 405.5), (81.0, 400.0),
(70.5, 399.5), (61.5, 410.0), (51.0, 420.5),
(43.5, 431.0), (38.5, 443.5), (31.0, 456.0),
(26.0, 468.0), (22.5, 483.0), (25.5, 496.5),
(32.5, 507.0), (37.5, 517.5), (41.5, 528.5),
(44.5, 540.5), (46.5, 552.0), (48.0, 563.0),
(49.0, 574.5), (50.0, 585.0), (51.0, 598.0),
(51.0, 609.0)])
db = cfg.database_root_gp
data_storage.create_database(db)
for filename in images_list:
print('Processing Image: %s...' % filename)
image_path = cfg.datasetRoot + '/' + filename
image = io.imread(image_path, as_gray=True)
fn = filename[0:-4]
g = data_storage.create_group(fn)
# Falta leer un JSON para cada estructura y cada forma
shape = femur_shape # shape simulada
pyramid = pyramid_gaussian.get_pyramid(image)
sigma = cfg.sigma_values
patch_size = cfg.patch_sizes
scales = cfg.scale_names
matrix = []
for p, s, ps, sc in zip(pyramid, sigma, patch_size, scales):
sg = data_storage.create_group(db, 'scale_' + sc, g)
img_grad = gp.get_gaussian_gradient_magnitude(p, s)
# Modificar mtx
patches = gp.sample_patches(img_grad, shape, (ps, ps))
for patch, i in zip(patches, range(1, len(patches) + 1)):
data_storage.save_data(sg, 'patch_' + str(i), patch)
shape /= cfg.downScaleFactor # escalamos las posiciones de los landmarks
centre = []
shape = np.vstack(subshapes[0])
x_val, y_val = shape.T
# subshape = json_reader.get_subshape(path, 12)
subshape = subshapes[0][3]
(cx, cy) = centroid(subshape)
centre.append((cx, cy))
print(shape.shape)
# print('All:',subshapes)
# print('One:', subshape)
print('Centroid:', cx, cy)
image = io.imread(cfg.imagePath, as_grey=True)
image = pg.get_pyramid(image)[0]
img_h, img_w = image.shape
# image = np.pad(image, ((50,), (50,)), 'constant', constant_values=(0,0))
fig, ax = plt.subplots()
################
# mapa de colores
# c = np.arange(1,20)
# cm = plt.get_cmap('rainbow') # pueden haber otras opciones en lugar de hsv,brg,etc
# no_points = len(c)
# ax.set_prop_cycle(cycler('color', [cm(1.*i/(no_points-1)) for i in range(no_points-1)]))
ax.set_prop_cycle(cycler('color', plt.cm.hsv(np.linspace(0.05, 1, 20))))
(patch_width, patch_height) = cfg.patch_shape
# x_values, y_values = sample_patches.sample_around_subshape(centre)
# x_values, y_values = sample_patches.sample_around_subshape(subshape, img_w, img_h)
(429.0, 536.5), (445.0, 530.0), (447.0, 514.5),
(448.5, 498.0), (449.5, 481.5), (447.0, 467.5),
(436.5, 468.5), (425.0, 468.0), (415.0, 467.5),
(403.5, 466.0), (393.5, 463.5), (383.5, 459.0),
(374.5, 454.0), (365.5, 448.5), (358.0, 441.0),
(352.0, 434.0), (346.0, 426.0), (340.0, 420.5),
(335.5, 412.5), (329.0, 405.5), (324.5, 397.5),
(318.5, 389.5), (313.5, 381.5), (308.0, 374.5),
(303.5, 366.5), (298.5, 358.0), (294.5, 350.5),
(289.0, 342.0), (286.5, 333.0), (284.0, 324.5),
(282.0, 315.5), (282.0, 305.0), (285.5, 295.5),
(293.0, 286.0), (295.0, 280.0)])
image = img
shape = femur_shape + 50
images_pyramid = pyramid_gaussian.get_pyramid(image)
patch_sizes = cfg.patch_sizes
for img, ps in zip(images_pyramid[::-1], patch_sizes[::-1]):
img = np.pad(img, cfg.padding, 'constant', constant_values=(0, 0))
img_grad = get_gaussian_gradient_magnitude(img)
# show_gradient_image(img_grad)
# show_gradient_image_patches(img_grad, shape, ps)
shape = (shape + 50) / cfg.downScaleFactor
# ax[1].imshow(img_grad, cmap=plt.cm.gray)
# plt.show()
# patches = sample_patches(img_grad, shape, (20, 20)) # estos parches se deben almacenar, vec es una matriz de parches
# plt.imshow(patches[0], cmap=plt.cm.gray)
# fig, (ax1,ax2) = plt.subplots(1,2, sharex=True, sharey=True)
def run():
gp_DB = cfg.database_root_gp
storage.create_database() # database for landmark detection
storage.create_database(gp_DB) # DB for gradient profiling
# images = glob.glob(cfg.datasetRoot+'/*.png')
# List of X-Ray images in PNG format
images_list = os.listdir(cfg.datasetRoot)
images_list = filter(lambda element: '.JPG' in element, images_list)
"""
images = []
for img in images_list:
if img.endswith('.png') or img.endswith('.JPG'):
images.append(img)
"""
###
# images_list = [img for img in os.listdir(cfg.datasetRoot) if img.endswith('.JPG')]
##############################################################
dataset_images = os.listdir(cfg.datasetRoot)
dataset_images = filter(lambda element: '.JPG' in element, dataset_images)
count = len(list(dataset_images))
print('Training', count, 'X-Ray Images')
# List for each bone structure
R_femurs = []
L_femurs = []
R_pelvis = []
L_pelvis = []
for filename in images_list:
print('Training Image: {0}...'.format(filename))
image_path = os.path.join(cfg.datasetRoot, filename)
image = io.imread(image_path, as_gray=True)
fn = filename[0:-4]
pyramid = pyramid_gaussian.get_pyramid(image)
json_file = os.path.join(cfg.path_json, fn + '.gsmdc')
structures = reader.get_all_subshapes(json_file)
im = storage.create_group(name=fn)
gp_gr = storage.create_group(gp_DB, fn)
for subshapes_, bone_name in zip(structures, cfg.bone_structures):
# For ASM
print('STRUCTURES', len(structures))
shape_ = np.array(np.vstack(subshapes_))
print('size', len(shape_))
if bone_name == cfg.bone_structures[0]:
R_femurs.append(shape_)
elif bone_name == cfg.bone_structures[1]:
R_pelvis.append(shape_)
elif bone_name == cfg.bone_structures[2]:
L_femurs.append(shape_)
elif bone_name == cfg.bone_structures[3]:
L_pelvis.append(shape_)
# For initial scale
subshapes = subshapes_ / (cfg.downScaleFactor ** (len(cfg.scale_names) - 1))
shape = shape_ / (cfg.downScaleFactor ** (len(cfg.scale_names) - 1))
init_flag = False
g = storage.create_group(name=bone_name, parent=im)
gp_group = storage.create_group(gp_DB, name=bone_name, parent=gp_gr)
for img, scale, sigma, patch_size in zip(pyramid, cfg.scale_names, cfg.sigma_values, cfg.patch_sizes):
# LANDMARK DETECTION DATA
print('Scale: {0} - Subshapes: {1} '.format(scale, len(subshapes)))
sg = storage.create_group(name='scale_' + scale, parent=g)
if scale == cfg.init_scale:
init_flag = True
subshapes = np.array([shape])
for i in range(len(subshapes)):
subs_g = storage.create_group(name='subshape_' + str(i), parent=sg)
try:
D, F, C = training_an_image(img, subshapes[i], init_flag)
storage.save_data(subs_g, 'D_' + fn, D)
storage.save_data(subs_g, 'F_' + fn, F)
storage.save_data(subs_g, 'C_' + fn, C)
if init_flag:
subshapes = subshapes_ / (cfg.downScaleFactor ** (len(cfg.scale_names) - 1))
init_flag = False
except:
print('Except subshape', i)
# GRADIENT PROFILING DATA
if scale != cfg.init_scale:
gp_g = storage.create_group(gp_DB, 'scale_' + scale, gp_group)
img_grad = grad_prof.get_gaussian_gradient_magnitude(img, sigma)
# img_grad = img
patches = grad_prof.sample_patches(img_grad, shape, (patch_size, patch_size))
mtx_patches = [np.ravel(patch) for patch in patches]
mtx_patches = np.array(mtx_patches).transpose()
storage.save_data(gp_g, 'patches', mtx_patches, gp_DB)
shape *= cfg.downScaleFactor
subshapes *= cfg.downScaleFactor
bone_structures = [R_femurs, R_pelvis, L_femurs, L_pelvis]
# ACTIVE SHAPE MODEL DATA
for bone_shapes, model in zip(bone_structures, cfg.models):
shapes = np.array(bone_shapes)
if len(shapes) > 1:
pca.run(shapes, model)
print('Training Finished')