print("... loading used configuration")
config = json.load(open(os.path.join(outfolder, "dnn_configuration.json"), "r"))
# loading test data
x_test, y_test = load_data("dataSauvola/test/", patch_size=patch_size, nb_random_patchs=5)
x_test = np.asarray(x_test, dtype=theano.config.floatX) # We convert to float32 to
y_test = np.asarray(y_test, dtype=theano.config.floatX) # compute on GPUs with CUDA
nTest = x_test.shape[0] # number of test examples
nFeats = x_test.shape[1] # number of features per input image
nLabels = y_test.shape[1] # number of labels per groundtruth
nn = MultiLayerPerceptron([nFeats] + config["hidden_geometry"] + [nLabels], outputActivation=crino.module.Sigmoid)
nn.setInputs(T.matrix("x"), nFeats)
nn.prepare()
nn.setParameters(pickle.load(open("./results/learned_params.pck")))
for i in xrange(0, nTest):
image = x_test[i].reshape(sqrt(nFeats), sqrt(nFeats))
estimated_binarisation = nn.forward(x_test[i : i + 1])
estimated_binarisation = threshold(estimated_binarisation)
estimated_image = estimated_binarisation.reshape(sqrt(nFeats), sqrt(nFeats))
gt = y_test[i].reshape(sqrt(nFeats), sqrt(nFeats))
plt.subplot(2, 2, 1)
plt.imshow(image, interpolation="nearest", cmap=plt.get_cmap("gray"), vmin=0.0, vmax=1.0)
def segmentation_ioda(imageHU):
"""
Effectue la segmentation à partir d'une image en HU.
"""
model_mat=sio.loadmat('./ioda_256/mean_model_256.mat')
modele=model_mat['model']
donnees_modele=modele[0,0]
image=imageHU.__deepcopy__(imageHU)
image=retirer_peau(image) #on retire la peau de la coupe
masque_muscle=get_masque(image,-29,150)
masque_muscle_resize=cv2.resize(masque_muscle,dsize=(256,256)) #interpolation des valeurs entre 0 et 1
masque_muscle_resize[masque_muscle_resize>0.5]=1
masque_muscle_resize[masque_muscle_resize<=0.5]=0
image=humuscle(image) #on ne garde que ce qui se trouve dans la plage des muscles
image=normalise(image) #on la normalise
image=scipy.misc.imresize(image,0.5) #reduction en image 256*256
image=normalise(image)
# --------------- recalage ----------------------
#/
#|
imageTemp = cv2.resize(imageHU,dsize=(256,256))
centre_lombaire_image_a_recaler=find_lumbar_center(imageTemp)
range_param=np.array([[-15,15],[0,1]])
m=image.shape[0]
n=image.shape[1]
matrice_recalage=recaler(image,donnees_modele,masque_muscle_resize,centre_lombaire_image_a_recaler[0:2],range_param,0,handle=False)
matrice_recalage_inverse=np.linalg.inv(matrice_recalage)
image=cv2.warpAffine(image,matrice_recalage_inverse[0:2,:],(n,m))
#|
#\
boxMat=sio.loadmat('./ioda_256/box_256.mat')
box=boxMat['infos']['box'][0][0]
minY=box[0][0]-1
maxY=box[0][1]
minX=box[1][0]-1
maxX=box[1][1]
image=image[minX:maxX,minY:maxY]
#--------------- initialisation du réseau --------------------------
print('Initialisation du réseau ...')
theano.config.floatX='float64' #initialisation
trained_weights = pickle.load(open('./ioda_256/learned_params_256.pck'))
nFeats=trained_weights['geometry'][0]
feats=nFeats
nLabels=nFeats
nHidden=trained_weights['geometry'][1]
geometry=[nFeats, nHidden, nHidden, nFeats] # on utilise la géométrie du fichier qui contient les learned_params
nn = MultiLayerPerceptron(geometry,outputActivation=crino.module.Sigmoid)
nn.linkInputs(theano.tensor.matrix('x'), nFeats)
nn.prepare(aPreparer=False)
nn.setParameters(trained_weights)
print('fin de l initialisation')
# --------------------- segmentation ---------------------------
print('Debut de la segmentation ...')
x_test = np.zeros((1,nFeats))
y_sortie = np.zeros((1,nFeats))
x_test = np.asarray(x_test, dtype=theano.config.floatX)
x_test=image.reshape((1,feats),order='F')
#---------------------------------forward---------------------------------
y_sortie = nn.forward(x_test[0:1])
y_sortie=normalise(y_sortie)
y_estim=np.zeros((157,229))
y_estim=y_sortie.reshape((157,229),order='F')
y_256=np.zeros((256,256))
y_256[45:202,17:246]=y_estim
sortie_recalee=cv2.warpAffine(y_256,matrice_recalage[0:2,:],(n,m))
y_512=scipy.misc.imresize(sortie_recalee,2.)
y_512=normalise(y_512)
masque=np.zeros((512,512))
masque=np.asarray(masque,dtype=int)
masque[y_512<0.2183]=0
masque[y_512>=0.2183]=1
print('Fin de la segmentation')
return masque
