def active_shape_model(X, testimg, max_iter, Nr_incisor, search_length):
"""
:param X: Init Guess
:param testimg: target image
:param max_iter: total iteration limitation
:param Nr_incisor: which nr. of incisor is used to do the asm
:return: a model describe the target incisor on the image
"""
img = median_filter(testimg)
img = bilateral_filter(img)
#img = top_hat_transform(img)
#img = bottom_hat_transform(img)
img = sobel(img)
#img = canny(img)
#img = sobel(img)
X = Landmarks(X).show_points()
# Initial value
nb_iter = 0
n_close = 0
total_s = 1
total_theta = 0
# Begin to iterate.
lm_objects = load_training_data(Nr_incisor)
landmarks_pca = PCA.ASM(lm_objects)
#search_length = 5
glm_range = 3
while (n_close < 16 and nb_iter <= max_iter):
# 1. Examine a region of the image around each point Xi to find the
# best nearby match for the point
"""
Y, n_close, quality = self.__findfits(X, img, gimg, glms, m)
if quality < best:
best = quality
best_Y = Y
Plotter.plot_landmarks_on_image([X, Y], testimg, wait=False,
title="Fitting incisor nr. %d" % (self.incisor_nr,))
# no good fit found => go back to best one
if nb_iter == max_iter:
Y = best_Y
"""
# Training glm
# cov, mean = grey_level_model(lm, glm_range)
# Y = find_the_best_score(X, img, search_length, glm_range, cov, mean)
Y = get_max_along_normal(X, search_length, img)
#print Y
# 2. Update the parameters (Xt, Yt, s, theta, b) to best fit the
# new found points X
b, t, s, theta = parameter_update(X, Y, Nr_incisor)
"""
Apply constraints to the parameters, b, to ensure plausible shapes
We clip each element b_i of b to b_max*sqrt(l_i) where l_i is the
corresponding eigenvalue.
"""
b = np.clip(b, -3, 3)
# t = np.clip(t, -5, 5)
# limit scaling
s = np.clip(s, 0.95, 1.05)
if total_s * s > 1.20 or total_s * s < 0.8:
s = 1
total_s *= s
# limit rotation
theta = np.clip(theta, -math.pi / 8, math.pi / 8)
if total_theta + theta > math.pi / 4 or total_theta + theta < -math.pi / 4:
theta = 0
total_theta += theta
"""Finish limitation"""
# The positions of the model points in the image, X, are then given
# by X = TXt,Yt,s,theta(X + Pb)
"""By updating X and apply equation 4, to map the dataset into image coordinates"""
X = Landmarks(X).as_vector()
X = Landmarks(X + np.dot(landmarks_pca.pc_modes, b)).T(t, s, theta)
#Plotter.plot_landmarks_on_image([X_prev, X], testimg, wait=False,
# title="Fitting incisor nr. %d" % (Nr_incisor,))
X = X.show_points()
"""Calibration"""
img2 = img.copy()
final_image = drawlines(img2, X)
cv2.imshow('iteration results ', final_image)
cv2.waitKey(10)
# cv2.imwrite('Data\Configure\iteration-%d.tif' % nb_iter, final_image)
nb_iter += 1
# print('this is the %d iteration'% nb_iter)
cv2.imwrite('Data\Configure\incisor-%d.tif' % Nr_incisor, final_image)
return X
self.w1 = w_load
self.b1 = b_load
def predict(self, test_x):
"""
get the answer of test_x by calculate logistic using the param learned before, and set the self.y_predict
param: test_x(np.array)
return: y_predict(np.array)
"""
print("predict......")
y_predict = self.sigmoid(np.dot(self.w1, test_x) + self.b1)
print("finish.......")
y_result = list()
for y in y_predict[0]:
if y > 0.5:
y_result.append(1)
else:
y_result.append(0)
self.y_predict = y_result
return y_result
if __name__ == "__main__":
x, y = load_training_data()
print(x.shape)
log_reg = logistic_regression(x, y)
log_reg.load_param()
test_x = load_test_data()
y_predict = log_reg.predict(test_x)
print(y_predict)
def parameter_update(X, Y, Nr_incisor):
"""This parts strictly follow Tim Cootes's paper as Protocol 1
Y should be given pointset or initial guess
X initial guess"""
lm_objects = load_training_data(Nr_incisor)
landmarks_pca = PCA.ASM(lm_objects)
b = np.zeros(landmarks_pca.pc_modes.shape[1])
b_prev = np.ones(landmarks_pca.pc_modes.shape[1])
i = 0
X = Landmarks(X).as_vector()
Y = Landmarks(Y)
while (np.mean(np.abs(b - b_prev)) >= 1e-14):
i += 1
# 2. Generate the model point positions using x = X + Pb
x = Landmarks(X + np.dot(landmarks_pca.pc_modes, b))
# 3. Find the pose parameters (Xt, Yt, s, theta) which best align the
# model points x to the current found points Y
t, s, theta = align_params(x, Y)
#t, s, theta = align_params(x.get_crown(is_upper), Y.get_crown(is_upper))
# 4. Project Y into the model co-ordinate frame by inverting the
# transformation T
y = Y.invT(t, s, theta)
# 5. Project y into the tangent plane to X by scaling:
# y' = y / (y*X).
yacc = Landmarks(y.as_vector() / np.dot(y.as_vector(), X.T))
# 6. Update the model parameters to match to y': b = PT(y' - X)
b_prev = b
b = np.dot(landmarks_pca.pc_modes.T, (yacc.as_vector() - X))
# 7. If not converged, return to step 2
"""
The discription is discussed in the paper.....
This function describe the opearation of changing from given lm to the model with convergended b.
We should iterate b first to make it convergence, then we get the final value of b, which is the only
meaningful value in this section. The eigen value b refers to a point in high dimension space which also
represents a model.
In this case, if another given 'model', like initial guess or lm, we must find this b. The way to find this b,
is to used this iteration method,
After b is convergence, then we know b is static and hence the model is steady, we then abstract the
pose(xt, yt, theta, s) for active shape model.
Generally speaking, accoording to equation 2 and 3, If b maintains the same, then x = xbar, then two models alignes well.
For some practical information.
Feed Xbar (PCA MEAN) and Y (Final goal state model).
By iteration using eqaition 2, we have new y (which is also the x in equation).
then we align the new obtained y to Final gaol state Y. and we have a tmp parameters.
The reason why we cannot get the final parameters after the alignment should be supported by the appendix 6 in paper.
In this case, we update b by using equation 3 and check if it is convergent.
If not, it shows the the previous obtained value y is not like the given model Y.
Then we need to continue iteration until b convergent.
What we want to get from this function is the transmission pose parameters.
"""
return b, t, s, theta
for i in range(8):
Nr_incisor = i + 1
source = 'Data\Landmarks\c_landmarks\landmarks1-%d.txt' % Nr_incisor
lm = Landmarks(source).show_points()
# print lm # you can print it to check differences.
"""Initial position guess"""
ini_pos = np.array([[570, 360, 390], [620, 470, 390], [640, 570, 370],
[570, 670, 370], [640, 400, 670], [630, 480, 670],
[620, 570, 630], [640, 650, 610]])
# ini_pos = np.array([[570, 360, 390], [570, 470, 390], [570, 570, 370], [570, 670, 370], [570, 400, 670],
# [470, 500, 680], [470, 590, 630], [470, 650, 610]])
s = ini_pos[i, 0]
t = [ini_pos[i, 1], ini_pos[i, 2]]
Golden_lm = load_training_data(Nr_incisor)
Golden_lm = rescale_withoutangle(gpa(Golden_lm)[2], t, s) # Y
img = cv2.imread('Data/Radiographs/01.tif', 0)
init_guess_img = img.copy()
crop_img_ori = crop(img, 1000, 500, 1000, 1000)
crop_img_init_guess = crop(init_guess_img, 1000, 500, 1000, 1000)
crop_correct_lm = crop(init_guess_img, 1000, 500, 1000, 1000)
#=======without crop
# crop_img_ori = img
# crop_img_init_guess = init_guess_img
# crop_correct_lm = init_guess_img
"""Drawing initial guess"""
#cv2.imshow('first golden model', drawlines(crop_img_init_guess, Golden_lm))
cv2.imwrite('Data\Configure\init_guess_incisor-%d.tif' % Nr_incisor,
drawlines(crop_img_init_guess, Golden_lm))
cv2.imwrite('Data\Configure\correct_lm_incisor-%d.tif' % Nr_incisor,
###
from util import load_training_data, load_testing_data
path_prefix = './'
def train_word2vec(x):
# 訓練 word to vector 的 word embedding
model = word2vec.Word2Vec(x,
size=250,
window=5,
min_count=5,
workers=12,
iter=10,
sg=1)
return model
if __name__ == "__main__":
print("loading training data ...")
train_x, y = load_training_data('training_label.txt')
train_x_no_label = load_training_data('training_nolabel.txt')
print("loading testing data ...")
test_x = load_testing_data('testing_data.txt')
model = train_word2vec(train_x + train_x_no_label + test_x)
#model = train_word2vec(train_x + test_x)
print("saving model ...")
#model.save(os.path.join(path_prefix, 'model/w2v_all.model'))
model.save(os.path.join(path_prefix, 'w2v_all.model'))
'BATCH_SIZE': 1000,
'NUM_EPOCHS': 1,
'LEARNING_RATE': 0.001,
'HIDDEN_LAYER_SIZE': 150,
'WORD_VECTOR_DIM': 200,
'SAVE_LOCATION': os.path.join('./checkpoints/', str(time.time))
}
print("# Loading training data")
training_data_raw = open(config['TRAINING_DATA_LOCATION'],'r',encoding='latin-1').readlines()
random.shuffle(training_data_raw)
num_examples = config['NUM_EXAMPLES']
training_data_raw= training_data_raw[:num_examples]
print("# Processing training data")
x_train, y_train, vocab_processor = util.load_training_data(training_data_raw)
print(" Loading and Processing testing data")
testing_data_raw = open(config['TESTING_DATA_LOCATION'],'r',encoding='latin-1').readlines()
x_test, y_test = util.load_testing_data(testing_data_raw, vocab_processor)
print("# Creating RNN")
rnn = TextRNN(x_train.shape[1], y_train.shape[1], config['HIDDEN_LAYER_SIZE'],
len(vocab_processor.vocabulary_), config['WORD_VECTOR_DIM'], l2_reg=0.0)
optimizer = tf.train.AdamOptimizer(config['LEARNING_RATE'])
minimizer = optimizer.minimize(rnn.loss)
print("# Initializing Tensorflow")
init_op = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init_op)
"""
mat = []
for lm in landmarks:
mat.append(lm.as_vector())
mat = np.array(mat)
return Landmarks(np.mean(mat, axis=0))
#def evaluation(X, Goldenlm)
if __name__ == '__main__':
Nr_incisor = 1
s = 500
t = [1370, 890]
Golden_lm = load_training_data(
Nr_incisor
) # the function in util refers to the file which only contains 02-14tif.
Golden_lm = rescale_withoutangle(gpa(Golden_lm)[2], t, s)
lm_objects = load_training_data(Nr_incisor)
landmarks_pca = PCA.ASM(lm_objects)
#print(np.shape(landmarks_pca.mu_value))
landmarks_pca_value = rescale_withoutangle(landmarks_pca.mu_value, t, s)
img = cv2.imread('Data/Radiographs/01.tif', 0)
img = img.copy()
img_withlm = drawlines(img, landmarks_pca_value)
crop_img = crop(img_withlm, 1000, 500, 1000, 1000)
img = cv2.resize(crop_img, (0, 0), fx=0.5, fy=0.5)
cv2.imshow('cropped_raw', crop_img)
#sobel = sobel(crop_img)
