Laboratoire RDP » Biophysics Team » FLORIVAR

def register_objects(img_flo, img_ref, preregisterd=True, ph=6, pl=2, es=5, fs=3, save_files=True, iterations=2):

	# -- "Specify paths to image files" --

	# ------------------------------------------------

	sequence_name = "register_"

	file_times = [1, 2]

	filenames = [sequence_name + str(t).zfill(2)  for t in file_times]

	list_images = [img_flo, img_ref]

	images = {}

	for i in [0,1]:

		images[filenames[i]] = list_images[i]

	rigid_images = {}

	rigid_transformations = {}

	affine_images = {}

	affine_transformations = {}

	registered_images = {}

	non_linear_transformations = {}

	[reference_filename, floating_filename, reference_time, floating_time] = [ filenames[0], filenames[1], file_times[0], file_times[1]]

	#for reference_filename, floating_filename, reference_time, floating_time, in zip(filenames[1:],filenames[:-1],file_times[1:],file_times[:-1]):

	print("================================")

	print("Registering ", floating_time, " on ", reference_time)

	print("================================")

	###################################################

	# Output structure

	###################################################

	namestring = "_ph"+str(ph)+"_pl"+str(pl)+"_es"+str(es)+"_fs"+str(fs)

	output_dirname = dirname + '/' + sequence_name + "_" + str(floating_time).zfill(2) + "_on_" + str(reference_time).zfill(2) + "" + namestring

	if not os.path.exists(output_dirname):

		os.makedirs(output_dirname)

	reference_img = images[reference_filename]

	floating_img = images[floating_filename]

	####################################################################

	# Registration of the floating images on ref

	# -----------------------------------------------------

	if (not preregistered) :

		# A. Find optimised rigid transformations

		rigid_img, rigid_trsf = find_rigid_transfo2(reference_img, floating_img)

		rigid_images[floating_filename] = rigid_img

		rigid_transformations[floating_filename] = rigid_trsf

		if save_files:

			# rigid-registered images

			rigid_filename = output_dirname + '/' + floating_filename + "_rigid_on_" + str(reference_time).zfill(2) + ".inr.gz"

			imsave(rigid_filename, rigid_img)

			# optimised (with block-matching) rigid transformations

			rigid_trsf_filename = output_dirname + '/tr_' + floating_filename + '_rigid.txt'

			tfsave(rigid_trsf_filename, rigid_trsf)

		# B. Find optimised affine transformations (initialised by the rigid tfs computed above)

		affine_img, affine_trsf = find_affine_transfo(reference_img, floating_img, init_trsf=rigid_trsf)

		affine_images[floating_filename] = affine_img

		affine_transformations[floating_filename] = affine_trsf

		if save_files:

			# affine-registered images

			affine_filename = output_dirname + '/' + floating_filename + "_affine_on_" + str(reference_time).zfill(2) + ".inr.gz"

			imsave(affine_filename, affine_img)

			# optimised (with block-matching) affine transformations

			affine_trsf_filename = output_dirname + '/tr_' + floating_filename + '_affine.txt'

			tfsave(affine_filename, affine_trsf)

		floating_img0=affine_img

	else :

		floating_img0=floating_img

	# C. Find nonlinear transformations which register the affine-transformed images

	#registered_img, nl_trsf = find_nl_transfo(reference_img, affine_img, ph=ph, pl=pl, es=es, fs=fs)

	for it in range(iterations):

		registered_img, nl_trsf = find_nl_transfo(reference_img, floating_img0, ph=ph, pl=pl, es=es, fs=fs)

		registered_images[floating_filename] = registered_img

		non_linear_transformations[floating_filename] = nl_trsf

		# paths to nonlinearly registered images

		registered_filename = output_dirname + '/' + floating_filename + "_registered_on_" + str(reference_time).zfill(2) + "_it"+str(it)+".inr.gz"

		imsave(registered_filename, registered_img)

		floating_img0=registered_img

		if save_files:

			# non-linear transformations

			nl_trsf_filename = output_dirname + '/' + floating_filename + "_it"+str(it)+"_vectorfield.inr.gz"

			save_trsf(nl_trsf, nl_trsf_filename, compress=True)

	return registered_img