Merge branch 'master' of git.elphel.com:Elphel/python3-imagej-tiff (4ecd26fe) · Commits · Elphel / python3-imagej-tiff

explore_data5.py

0 → 100644

+1147 −0

File added.

Preview size limit exceeded, changes collapsed.

nn_ds_neibs16.py

+12 −12

Original line number	Original line	Diff line number	Diff line
	#!/usr/bin/env python3		#!/usr/bin/env python3
	from numpy import float64		##from numpy import float64
	from tensorflow.contrib.losses.python.metric_learning.metric_loss_ops import npairs_loss		##from tensorflow.contrib.losses.python.metric_learning.metric_loss_ops import npairs_loss
	from debian.deb822 import PdiffIndex		##from debian.deb822 import PdiffIndex

	__copyright__ = "Copyright 2018, Elphel, Inc."		__copyright__ = "Copyright 2018, Elphel, Inc."
	__license__ = "GPL-3.0+"		__license__ = "GPL-3.0+"
	__email__ = "andrey@elphel.com"		__email__ = "andrey@elphel.com"


	from PIL import Image		##from PIL import Image

	import os		import os
	import sys		import sys
	import glob		##import glob

	import numpy as np		import numpy as np
	import itertools		##import itertools

	import time		import time

	import matplotlib.pyplot as plt		##import matplotlib.pyplot as plt

	import shutil		import shutil
	from threading import Thread		from threading import Thread
	@@ -49,7 +49,7 @@ except IndexError:
	root_dir = os.path.dirname(conf_file)		root_dir = os.path.dirname(conf_file)

	print ("Configuration file: " + conf_file)		print ("Configuration file: " + conf_file)
	parameters, dirs, files = qsf.parseXmlConfig(conf_file, root_dir)		parameters, dirs, files, _ = qsf.parseXmlConfig(conf_file, root_dir)
	"""		"""
	Temporarily for backward compatibility		Temporarily for backward compatibility
	"""		"""
	@@ -221,7 +221,7 @@ if SPREAD_CONVERGENCE:

	else:		else:
	outs, inp_weights = qcstereo_network.networks_siam(		outs, inp_weights = qcstereo_network.networks_siam(
	input= corr2d_Nx325,		input_tensor= corr2d_Nx325,
	input_global = None,		input_global = None,
	layout1 = NN_LAYOUT1,		layout1 = NN_LAYOUT1,
	layout2 = NN_LAYOUT2,		layout2 = NN_LAYOUT2,
	@@ -247,7 +247,7 @@ G_losses[0], _disp_slice, _d_gt_slice, _out_diff, _out_diff2, _w_norm, _out_wdif
	absolute_disparity = ABSOLUTE_DISPARITY,		absolute_disparity = ABSOLUTE_DISPARITY,
	use_confidence = USE_CONFIDENCE, # True,		use_confidence = USE_CONFIDENCE, # True,
	lambda_conf_avg = 0.01,		lambda_conf_avg = 0.01,
	lambda_conf_pwr = 0.1,		## lambda_conf_pwr = 0.1,
	conf_pwr = 2.0,		conf_pwr = 2.0,
	gt_conf_offset = 0.08,		gt_conf_offset = 0.08,
	gt_conf_pwr = 2.0,		gt_conf_pwr = 2.0,
	@@ -268,7 +268,7 @@ for n in range (1,len(partials)):
	absolute_disparity = ABSOLUTE_DISPARITY,		absolute_disparity = ABSOLUTE_DISPARITY,
	use_confidence = USE_CONFIDENCE, # True,		use_confidence = USE_CONFIDENCE, # True,
	lambda_conf_avg = 0.01,		lambda_conf_avg = 0.01,
	lambda_conf_pwr = 0.1,		# lambda_conf_pwr = 0.1,
	conf_pwr = 2.0,		conf_pwr = 2.0,
	gt_conf_offset = 0.08,		gt_conf_offset = 0.08,
	gt_conf_pwr = 2.0,		gt_conf_pwr = 2.0,

nn_eval_01.py

0 → 100644

+200 −0

Original line number	Original line	Diff line number	Diff line
			#!/usr/bin/env python3

			__copyright__ = "Copyright 2018, Elphel, Inc."
			__license__ = "GPL-3.0+"
			__email__ = "andrey@elphel.com"


			from PIL import Image

			import os
			import sys
			import glob

			import numpy as np

			import time

			import matplotlib.pyplot as plt

			import qcstereo_functions as qsf

			#import xml.etree.ElementTree as ET

			qsf.TIME_START = time.time()
			qsf.TIME_LAST = qsf.TIME_START

			IMG_WIDTH = 324 # tiles per image row
			DEBUG_LEVEL= 1

			try:
			conf_file = sys.argv[1]
			except IndexError:
			print("Configuration path is required as a first argument. Optional second argument specifies root directory for data files")
			exit(1)
			try:
			root_dir = sys.argv[2]
			except IndexError:
			root_dir = os.path.dirname(conf_file)

			print ("Configuration file: " + conf_file)
			parameters, dirs, files, dbg_parameters = qsf.parseXmlConfig(conf_file, root_dir)
			"""
			Temporarily for backward compatibility
			"""
			if not "SLOSS_CLIP" in parameters:
			parameters['SLOSS_CLIP'] = 0.5
			print ("Old config, setting SLOSS_CLIP=", parameters['SLOSS_CLIP'])

			"""
			Defined in config file
			"""
			TILE_SIDE, TILE_LAYERS, TWO_TRAINS, NET_ARCH1, NET_ARCH2 = [None]*5
			ABSOLUTE_DISPARITY,SYM8_SUB, WLOSS_LAMBDA, SLOSS_LAMBDA, SLOSS_CLIP = [None]*5
			SPREAD_CONVERGENCE, INTER_CONVERGENCE, HOR_FLIP, DISP_DIFF_CAP, DISP_DIFF_SLOPE = [None]*5
			CLUSTER_RADIUS,ABSOLUTE_DISPARITY = [None]*2

			globals().update(parameters)


			#exit(0)


			TILE_SIZE = TILE_SIDE* TILE_SIDE # == 81
			FEATURES_PER_TILE = TILE_LAYERS * TILE_SIZE# == 324
			BATCH_SIZE = ([1,2][TWO_TRAINS])21000//25 # == 80 Each batch of tiles has balanced D/S tiles, shuffled batches but not inside batches

			SUFFIX=(str(NET_ARCH1)+'-'+str(NET_ARCH2)+
			(["R","A"][ABSOLUTE_DISPARITY]) +
			(["NS","S8"][SYM8_SUB])+
			"WLAM"+str(WLOSS_LAMBDA)+
			"SLAM"+str(SLOSS_LAMBDA)+
			"SCLP"+str(SLOSS_CLIP)+
			(['_nG','_G'][SPREAD_CONVERGENCE])+
			(['_nI','_I'][INTER_CONVERGENCE]) +
			(['_nHF',"_HF"][HOR_FLIP]) +
			('_CP'+str(DISP_DIFF_CAP)) +
			('_S'+str(DISP_DIFF_SLOPE))
			)

			##############################################################################
			cluster_size = (2 * CLUSTER_RADIUS + 1) * (2 * CLUSTER_RADIUS + 1)
			center_tile_index = 2 * CLUSTER_RADIUS * (CLUSTER_RADIUS + 1)
			qsf.prepareFiles(dirs, files, suffix = SUFFIX)

			#import tensorflow.contrib.slim as slim
			NN_DISP = 0
			HEUR_DISP = 1
			GT_DISP = 2
			GT_CONF = 3
			NN_NAN = 4
			HEUR_NAN = 5
			NN_DIFF = 6
			HEUR_DIFF = 7
			CONF_MAX = 0.7
			ERR_AMPL = 0.3
			TIGHT_TOP = 0.95
			TIGHT_HPAD = 1.0
			TIGHT_WPAD = 1.0
			FIGSIZE = [8.5,11.0]
			WOI_COLOR = "red"

			#dbg_parameters
			def get_fig_params(disparity_ranges):
			fig_params = []
			for dr in disparity_ranges:
			if dr[-1][0]=='-':
			fig_params.append(None)
			else:
			subs = []
			for s in dr[:-1]:
			mm = s[:2]
			try:
			lims = s[2]
			except IndexError:
			lims = None
			subs.append({'lim_val':mm, 'lim_xy':lims})
			fig_params.append({'name':dr[-1],'ranges':subs})
			return fig_params

			#try:
			fig_params = get_fig_params(dbg_parameters['disparity_ranges'])

			pass
			figs = []
			def setlimsxy(lim_xy):
			if not lim_xy is None:
			plt.xlim(min(lim_xy[:2]),max(lim_xy[:2]))
			plt.ylim(max(lim_xy[2:]),min(lim_xy[2:]))

			for nfile, fpars in enumerate(fig_params):
			if not fpars is None:
			data = qsf.result_npy_prepare(files['result'][nfile], ABSOLUTE_DISPARITY, fix_nan=True, insert_deltas=True)

			for rng in fpars['ranges']:
			lim_val = rng['lim_val']
			lim_xy = rng['lim_xy']
			fig = plt.figure(figsize=FIGSIZE)
			fig.canvas.set_window_title(fpars['name'])
			fig.suptitle(fpars['name'])
			ax_conf=plt.subplot(322)
			ax_conf.set_title("Ground truth confidence")
			# fig.suptitle("Groud truth confidence")
			plt.imshow(data[...,GT_CONF], vmin=0, vmax=CONF_MAX, cmap='gray')
			if not lim_xy is None:
			pass # show frame
			xdata=[min(lim_xy[:2]),max(lim_xy[:2]),max(lim_xy[:2]),min(lim_xy[:2]),min(lim_xy[:2])]
			ydata=[min(lim_xy[2:]),min(lim_xy[2:]),max(lim_xy[2:]),max(lim_xy[2:]),min(lim_xy[2:])]
			plt.plot(xdata,ydata,color=WOI_COLOR)

			# setlimsxy(lim_xy)
			plt.colorbar(orientation='vertical') # location='bottom')

			ax_gtd=plt.subplot(321)
			ax_gtd.set_title("Ground truth disparity map")
			plt.imshow(data[...,GT_DISP], vmin=lim_val[0], vmax=lim_val[1])
			setlimsxy(lim_xy)
			plt.colorbar(orientation='vertical') # location='bottom')

			ax_hed=plt.subplot(323)
			ax_hed.set_title("Heuristic disparity map")
			plt.imshow(data[...,HEUR_NAN], vmin=lim_val[0], vmax=lim_val[1])
			setlimsxy(lim_xy)
			plt.colorbar(orientation='vertical') # location='bottom')

			ax_nnd=plt.subplot(325)
			ax_nnd.set_title("Network disparity output")
			plt.imshow(data[...,NN_NAN], vmin=lim_val[0], vmax=lim_val[1])
			setlimsxy(lim_xy)
			plt.colorbar(orientation='vertical') # location='bottom')

			ax_hee=plt.subplot(324)
			ax_hee.set_title("Heuristic disparity error")
			plt.imshow(data[...,HEUR_DIFF], vmin=-ERR_AMPL, vmax=ERR_AMPL)
			setlimsxy(lim_xy)
			plt.colorbar(orientation='vertical') # location='bottom')

			ax_nne=plt.subplot(326)
			ax_nne.set_title("Network disparity error")
			plt.imshow(data[...,NN_DIFF], vmin=-ERR_AMPL, vmax=ERR_AMPL)
			setlimsxy(lim_xy)
			plt.colorbar(orientation='vertical') # location='bottom')

			plt.tight_layout(rect =[0,0,1,TIGHT_TOP], h_pad = TIGHT_HPAD, w_pad = TIGHT_WPAD)

			figs.append(fig)
			pass

			#whow to allow adjustment before applying tight_layout?
			pass
			for fig in figs:
			fig.tight_layout(rect =[0,0,1,TIGHT_TOP], h_pad = TIGHT_HPAD, w_pad = TIGHT_WPAD)
			plt.show()



			#qsf.evaluateAllResults(result_files = files['result'],
			# absolute_disparity = ABSOLUTE_DISPARITY,
			# cluster_radius = CLUSTER_RADIUS)
			print("All done")
			exit (0)

qcstereo_functions.py

+42 −26

Original line number	Original line	Diff line number	Diff line
	@@ -30,13 +30,14 @@ def print_time(txt="",end="\n"):
	txt +=" "		txt +=" "
	print(("%s"+bcolors.BOLDWHITE+"at %.4fs (+%.4fs)"+bcolors.ENDC)%(txt,t-TIME_START,t-TIME_LAST), end = end, flush=True)		print(("%s"+bcolors.BOLDWHITE+"at %.4fs (+%.4fs)"+bcolors.ENDC)%(txt,t-TIME_START,t-TIME_LAST), end = end, flush=True)
	TIME_LAST = t		TIME_LAST = t

	def parseXmlConfig(conf_file, root_dir):		def parseXmlConfig(conf_file, root_dir):
	tree = ET.parse(conf_file)		tree = ET.parse(conf_file)
	root = tree.getroot()		root = tree.getroot()
	parameters = {}		parameters = {}
	for p in root.find('parameters'):		for p in root.find('parameters'):
	parameters[p.tag]=eval(p.text.strip())		parameters[p.tag]=eval(p.text.strip())
	globals		# globals
	dirs={}		dirs={}
	for p in root.find('directories'):		for p in root.find('directories'):
	dirs[p.tag]=eval(p.text.strip())		dirs[p.tag]=eval(p.text.strip())
	@@ -46,7 +47,11 @@ def parseXmlConfig(conf_file, root_dir):
	for p in root.find('files'):		for p in root.find('files'):
	files[p.tag]=eval(p.text.strip())		files[p.tag]=eval(p.text.strip())
	# globals().update(parameters)		# globals().update(parameters)
	return parameters, dirs, files		dbg_parameters = {}
			for p in root.find('dbg_parameters'):
			dbg_parameters[p.tag]=eval(p.text.strip())

			return parameters, dirs, files, dbg_parameters



	@@ -84,7 +89,8 @@ def readTFRewcordsEpoch(train_filename):
	npy_dir_name = "npy"		npy_dir_name = "npy"
	dirname = os.path.dirname(train_filename)		dirname = os.path.dirname(train_filename)
	npy_dir = os.path.join(dirname, npy_dir_name)		npy_dir = os.path.join(dirname, npy_dir_name)
	filebasename, file_extension = os.path.splitext(train_filename)		# filebasename, file_extension = os.path.splitext(train_filename)
			filebasename, _ = os.path.splitext(train_filename)
	filebasename = os.path.basename(filebasename)		filebasename = os.path.basename(filebasename)
	file_corr2d = os.path.join(npy_dir,filebasename + '_corr2d.npy')		file_corr2d = os.path.join(npy_dir,filebasename + '_corr2d.npy')
	file_target_disparity = os.path.join(npy_dir,filebasename + '_target_disparity.npy')		file_target_disparity = os.path.join(npy_dir,filebasename + '_target_disparity.npy')
	@@ -179,7 +185,7 @@ def add_neibs(npa_ext,radius):
	height = npa_ext.shape[0]-2*radius		height = npa_ext.shape[0]-2*radius
	width = npa_ext.shape[1]-2*radius		width = npa_ext.shape[1]-2*radius
	side = 2 * radius + 1		side = 2 * radius + 1
	size = side * side		# size = side * side
	npa_neib = np.empty((height, width, side, side, npa_ext.shape[2]), dtype = npa_ext.dtype)		npa_neib = np.empty((height, width, side, side, npa_ext.shape[2]), dtype = npa_ext.dtype)
	for dy in range (side):		for dy in range (side):
	for dx in range (side):		for dx in range (side):
	@@ -187,8 +193,8 @@ def add_neibs(npa_ext,radius):
	return npa_neib.reshape(height, width, -1)		return npa_neib.reshape(height, width, -1)

	def extend_img_to_clusters(datasets_img,radius, width): # = 324):		def extend_img_to_clusters(datasets_img,radius, width): # = 324):
	side = 2 * radius + 1		# side = 2 * radius + 1
	size = side * side		# size = side * side
	if len(datasets_img) ==0:		if len(datasets_img) ==0:
	return		return
	num_tiles = datasets_img[0]['corr2d'].shape[0]		num_tiles = datasets_img[0]['corr2d'].shape[0]
	@@ -210,7 +216,7 @@ def reformat_to_clusters(datasets_data, cluster_radius):

	def flip_horizontal(datasets_data, cluster_radius, tile_layers, tile_side):		def flip_horizontal(datasets_data, cluster_radius, tile_layers, tile_side):
	cluster_side = 2 * cluster_radius + 1		cluster_side = 2 * cluster_radius + 1
	cluster_size = cluster_side * cluster_side		# cluster_size = cluster_side * cluster_side
	"""		"""
	TILE_LAYERS = 4		TILE_LAYERS = 4
	TILE_SIDE = 9 # 7		TILE_SIDE = 9 # 7
	@@ -238,8 +244,8 @@ TILE_SIZE = TILE_SIDE* TILE_SIDE # == 81
	rec['target_disparity'] = target_disparity.reshape((target_disparity.shape[0],-1))		rec['target_disparity'] = target_disparity.reshape((target_disparity.shape[0],-1))
	rec['gt_ds'] = gt_ds.reshape((gt_ds.shape[0],-1))		rec['gt_ds'] = gt_ds.reshape((gt_ds.shape[0],-1))

	def replace_nan(datasets_data, cluster_radius):		def replace_nan(datasets_data): # , cluster_radius):
	cluster_size = (2 * cluster_radius + 1) * (2 * cluster_radius + 1)		# cluster_size = (2 * cluster_radius + 1) * (2 * cluster_radius + 1)
	# Reformat input data		# Reformat input data
	for rec in datasets_data:		for rec in datasets_data:
	if not rec is None:		if not rec is None:
	@@ -259,7 +265,7 @@ def permute_to_swaps(perm):

	def shuffle_in_place(datasets_data, indx, period):		def shuffle_in_place(datasets_data, indx, period):
	swaps = permute_to_swaps(np.random.permutation(len(datasets_data)))		swaps = permute_to_swaps(np.random.permutation(len(datasets_data)))
	num_entries = datasets_data[0]['corr2d'].shape[0] // period		# num_entries = datasets_data[0]['corr2d'].shape[0] // period
	for swp in swaps:		for swp in swaps:
	ds0 = datasets_data[swp[0]]		ds0 = datasets_data[swp[0]]
	ds1 = datasets_data[swp[1]]		ds1 = datasets_data[swp[1]]
	@@ -279,9 +285,10 @@ def shuffle_chunks_in_place(datasets_data, tiles_groups_per_chunk):
	"""		"""
	Improve shuffling by preserving indices inside batches (0 <->0, ... 39 <->39 for 40 tile group batches)		Improve shuffling by preserving indices inside batches (0 <->0, ... 39 <->39 for 40 tile group batches)
	"""		"""
	num_files = len(datasets_data)		# num_files = len(datasets_data)
	#chunks_per_file = datasets_data[0]['target_disparity']		#chunks_per_file = datasets_data[0]['target_disparity']
	for nf, ds in enumerate(datasets_data):		# for nf, ds in enumerate(datasets_data):
			for ds in datasets_data:
	groups_per_file = ds['corr2d'].shape[0]		groups_per_file = ds['corr2d'].shape[0]
	chunks_per_file = groups_per_file//tiles_groups_per_chunk		chunks_per_file = groups_per_file//tiles_groups_per_chunk
	permut = np.random.permutation(chunks_per_file)		permut = np.random.permutation(chunks_per_file)
	@@ -327,7 +334,8 @@ def zip_lvar_hvar(datasets_all_data, del_src = True):
	'target_disparity': np.empty((recs[0]['target_disparity'].shape[0]*num_sets_to_combine,recs[0]['target_disparity'].shape[1]),dtype=np.float32),		'target_disparity': np.empty((recs[0]['target_disparity'].shape[0]*num_sets_to_combine,recs[0]['target_disparity'].shape[1]),dtype=np.float32),
	'gt_ds': np.empty((recs[0]['gt_ds'].shape[0]*num_sets_to_combine, recs[0]['gt_ds'].shape[1]),dtype=np.float32)}		'gt_ds': np.empty((recs[0]['gt_ds'].shape[0]*num_sets_to_combine, recs[0]['gt_ds'].shape[1]),dtype=np.float32)}

	for nset, reci in enumerate(recs):		# for nset, reci in enumerate(recs):
			for nset, _ in enumerate(recs):
	rec['corr2d'] [nset::num_sets_to_combine] = recs[nset]['corr2d']		rec['corr2d'] [nset::num_sets_to_combine] = recs[nset]['corr2d']
	rec['target_disparity'][nset::num_sets_to_combine] = recs[nset]['target_disparity']		rec['target_disparity'][nset::num_sets_to_combine] = recs[nset]['target_disparity']
	rec['gt_ds'] [nset::num_sets_to_combine] = recs[nset]['gt_ds']		rec['gt_ds'] [nset::num_sets_to_combine] = recs[nset]['gt_ds']
	@@ -356,10 +364,10 @@ def initTrainTestData(
	max_files_per_group, # shuffling buffer for files		max_files_per_group, # shuffling buffer for files
	two_trains,		two_trains,
	train_next):		train_next):
	datasets_train_lvar = []		# datasets_train_lvar = []
	datasets_train_hvar = []		# datasets_train_hvar = []
	datasets_train_lvar1 = []		# datasets_train_lvar1 = []
	datasets_train_hvar1 = []		# datasets_train_hvar1 = []
	datasets_train_all = [[],[],[],[]]		datasets_train_all = [[],[],[],[]]
	for n_train, f_train in enumerate(files['train']):		for n_train, f_train in enumerate(files['train']):
	if len(f_train) and ((n_train<2) or two_trains):		if len(f_train) and ((n_train<2) or two_trains):
	@@ -445,7 +453,8 @@ def readImageData(image_data,
	cluster_radius,		cluster_radius,
	width)		width)
	if replace_nans:		if replace_nans:
	replace_nan([image_data[indx]], cluster_radius)		# replace_nan([image_data[indx]], cluster_radius)
			replace_nan([image_data[indx]])

	return image_data[indx]		return image_data[indx]

	@@ -477,7 +486,7 @@ def evaluateAllResults(result_files, absolute_disparity, cluster_radius):



	def result_npy_to_tiff(npy_path, absolute, fix_nan, insert_deltas=True):		def result_npy_prepare(npy_path, absolute, fix_nan, insert_deltas=True):

	"""		"""
	@param npy_path full path to the npy file with 4-layer data (242,324,4) - nn_disparity(offset), target_disparity, gt disparity, gt strength		@param npy_path full path to the npy file with 4-layer data (242,324,4) - nn_disparity(offset), target_disparity, gt disparity, gt strength
	@@ -485,10 +494,9 @@ def result_npy_to_tiff(npy_path, absolute, fix_nan, insert_deltas=True):
	@param absolute - True - the first layer contains absolute disparity, False - difference from target_disparity		@param absolute - True - the first layer contains absolute disparity, False - difference from target_disparity
	@param fix_nan - replace nan in target_disparity with 0 to apply offset, target_disparity will still contain nan		@param fix_nan - replace nan in target_disparity with 0 to apply offset, target_disparity will still contain nan
	"""		"""
	tiff_path = npy_path.replace('.npy','.tiff')
	data = np.load(npy_path) #(324,242,4) [nn_disp, target_disp,gt_disp, gt_conf]		data = np.load(npy_path) #(324,242,4) [nn_disp, target_disp,gt_disp, gt_conf]
	nn_out = 0		nn_out = 0
	target_disparity = 1		# target_disparity = 1
	gt_disparity = 2		gt_disparity = 2
	gt_strength = 3		gt_strength = 3
	if not absolute:		if not absolute:
	@@ -501,20 +509,28 @@ def result_npy_to_tiff(npy_path, absolute, fix_nan, insert_deltas=True):
	data = np.concatenate([data[...,0:4],data[...,0:2],data[...,0:2],data[...,4:]], axis = 2)		data = np.concatenate([data[...,0:4],data[...,0:2],data[...,0:2],data[...,4:]], axis = 2)
	data[...,6] -= data[...,gt_disparity]		data[...,6] -= data[...,gt_disparity]
	data[...,7] -= data[...,gt_disparity]		data[...,7] -= data[...,gt_disparity]
	for l in [4,5,6,7]:		for l in [2, 4, 5, 6, 7]:
	data[...,l] = np.select([data[...,gt_strength]==0.0, data[...,gt_strength]>0.0], [np.nan,data[...,l]])		data[...,l] = np.select([data[...,gt_strength]==0.0, data[...,gt_strength]>0.0], [np.nan,data[...,l]])
	# All other layers - mast too		# All other layers - mast too
	for l in range(8,data.shape[2]):		for l in range(8,data.shape[2]):
	data[...,l] = np.select([data[...,gt_strength]==0.0, data[...,gt_strength]>0.0], [np.nan,data[...,l]])		data[...,l] = np.select([data[...,gt_strength]==0.0, data[...,gt_strength]>0.0], [np.nan,data[...,l]])
			return data

			def result_npy_to_tiff(npy_path, absolute, fix_nan, insert_deltas=True):

	# data[...,4] = np.select([data[...,3]==0.0, data[...,3]>0.0], [np.nan,data[...,4]])		"""
	# data[...,5] = np.select([data[...,3]==0.0, data[...,3]>0.0], [np.nan,data[...,5]])		@param npy_path full path to the npy file with 4-layer data (242,324,4) - nn_disparity(offset), target_disparity, gt disparity, gt strength
			data will be written as 4-layer tiff, extension '.npy' replaced with '.tiff'
			@param absolute - True - the first layer contains absolute disparity, False - difference from target_disparity
			@param fix_nan - replace nan in target_disparity with 0 to apply offset, target_disparity will still contain nan
			"""
			data = result_npy_prepare(npy_path, absolute, fix_nan, insert_deltas)
			tiff_path = npy_path.replace('.npy','.tiff')

	data = data.transpose(2,0,1)		data = data.transpose(2,0,1)
	print("Saving results to TIFF: "+tiff_path)		print("Saving results to TIFF: "+tiff_path)
	imagej_tiffwriter.save(tiff_path,data[...,np.newaxis])		imagej_tiffwriter.save(tiff_path,data[...,np.newaxis])


	def eval_results(rslt_path, absolute,		def eval_results(rslt_path, absolute,
	min_disp = -0.1, #minimal GT disparity		min_disp = -0.1, #minimal GT disparity
	max_disp = 20.0, # maximal GT disparity		max_disp = 20.0, # maximal GT disparity

qcstereo_losses.py

+6 −6

Original line number	Original line	Diff line number	Diff line
	@@ -4,7 +4,7 @@ __license__ = "GPL-3.0+"
	__email__ = "andrey@elphel.com"		__email__ = "andrey@elphel.com"

	#from numpy import float64		#from numpy import float64
	import numpy as np		#import numpy as np
	import tensorflow as tf		import tensorflow as tf

	def smoothLoss(out_batch, # [batch_size,(1..2)] tf_result		def smoothLoss(out_batch, # [batch_size,(1..2)] tf_result
	@@ -76,7 +76,7 @@ def batchLoss(out_batch, # [batch_size,(1..2)] tf_result
	absolute_disparity = False, #when false there should be no activation on disparity output !		absolute_disparity = False, #when false there should be no activation on disparity output !
	use_confidence = False,		use_confidence = False,
	lambda_conf_avg = 0.01,		lambda_conf_avg = 0.01,
	lambda_conf_pwr = 0.1,		## lambda_conf_pwr = 0.1,
	conf_pwr = 2.0,		conf_pwr = 2.0,
	gt_conf_offset = 0.08,		gt_conf_offset = 0.08,
	gt_conf_pwr = 1.0,		gt_conf_pwr = 1.0,
	@@ -90,14 +90,14 @@ def batchLoss(out_batch, # [batch_size,(1..2)] tf_result
	Here confidence should be after relU. Disparity - may be also if absolute, but no activation if output is residual disparity		Here confidence should be after relU. Disparity - may be also if absolute, but no activation if output is residual disparity
	"""		"""
	tf_lambda_conf_avg = tf.constant(lambda_conf_avg, dtype=tf.float32, name="tf_lambda_conf_avg")		tf_lambda_conf_avg = tf.constant(lambda_conf_avg, dtype=tf.float32, name="tf_lambda_conf_avg")
	tf_lambda_conf_pwr = tf.constant(lambda_conf_pwr, dtype=tf.float32, name="tf_lambda_conf_pwr")		## tf_lambda_conf_pwr = tf.constant(lambda_conf_pwr, dtype=tf.float32, name="tf_lambda_conf_pwr")
	tf_conf_pwr = tf.constant(conf_pwr, dtype=tf.float32, name="tf_conf_pwr")		## tf_conf_pwr = tf.constant(conf_pwr, dtype=tf.float32, name="tf_conf_pwr")
	tf_gt_conf_offset = tf.constant(gt_conf_offset, dtype=tf.float32, name="tf_gt_conf_offset")		tf_gt_conf_offset = tf.constant(gt_conf_offset, dtype=tf.float32, name="tf_gt_conf_offset")
	tf_gt_conf_pwr = tf.constant(gt_conf_pwr, dtype=tf.float32, name="tf_gt_conf_pwr")		tf_gt_conf_pwr = tf.constant(gt_conf_pwr, dtype=tf.float32, name="tf_gt_conf_pwr")
	tf_num_tiles = tf.shape(gt_ds_batch)[0]		tf_num_tiles = tf.shape(gt_ds_batch)[0]
	tf_0f = tf.constant(0.0, dtype=tf.float32, name="tf_0f")		tf_0f = tf.constant(0.0, dtype=tf.float32, name="tf_0f")
	tf_1f = tf.constant(1.0, dtype=tf.float32, name="tf_1f")		tf_1f = tf.constant(1.0, dtype=tf.float32, name="tf_1f")
	tf_maxw = tf.constant(1.0, dtype=tf.float32, name="tf_maxw")		## tf_maxw = tf.constant(1.0, dtype=tf.float32, name="tf_maxw")
	tf_disp_diff_cap2= tf.constant(disp_diff_cap*disp_diff_cap, dtype=tf.float32, name="disp_diff_cap2")		tf_disp_diff_cap2= tf.constant(disp_diff_cap*disp_diff_cap, dtype=tf.float32, name="disp_diff_cap2")
	tf_disp_diff_slope= tf.constant(disp_diff_slope, dtype=tf.float32, name="disp_diff_slope")		tf_disp_diff_slope= tf.constant(disp_diff_slope, dtype=tf.float32, name="disp_diff_slope")

Admin message