def save_data(self,
x,
name,
save_dir,
x_is_real_x=False,
batch_image_fn=None,
emphasize=None):
"""Save dataspace instances.
Args:
x: A numpy array of dataspace points.
name: A string indicating the name in the saved file.
save_dir: A string indicating the directory to put the saved file.
x_is_real_x: An boolean indicating whether `x` is already in dataspace. If
not, `x` is converted to dataspace before saving
batch_image_fn: An function that batches images. If not specified,
default function `common.batch_image` will be used.
emphasize: An optional list of indecies of x to emphasize. It not specied,
nothing would be empasized.
"""
batch_image_fn = batch_image_fn or common.batch_image
if not x_is_real_x:
np.savetxt(join(save_dir, '%s.array.txt' % name), x)
real_x = x if x_is_real_x else self.decode(x)
real_x = common.post_proc(real_x, self.config, emphasize=emphasize)
batched_real_x = batch_image_fn(real_x)
sample_file = join(save_dir, '%s.png' % name)
common.save_image(batched_real_x, sample_file)
def save_data(self,
x,
name,
save_dir,
x_is_real_x=False,
batch_image_fn=None,
emphasize=None):
"""Save dataspace instances.
Args:
x: A numpy array of dataspace points.
name: A string indicating the name in the saved file.
save_dir: A string indicating the directory to put the saved file.
x_is_real_x: An boolean indicating whether `x` is already in dataspace. If
not, `x` is converted to dataspace before saving
"""
if not x_is_real_x:
np.savetxt(join(save_dir, '%s.x_array.txt' % name), x)
real_x = x if x_is_real_x else self.decode(x)
batched_real_x = common.batch_audio(real_x)
sample_file = join(save_dir, '%s.wav' % name)
wavfile.write(sample_file, rate=16000, data=batched_real_x)
spectrum = common.audio_to_spectrum(real_x)
spectrum = common.post_proc(spectrum, self.config, emphasize=emphasize)
batched_spectrum = (batch_image_fn or common.batch_image)(spectrum)
spectrum_sample_file = join(save_dir, '%s.spectrum.png' % name)
common.save_image(batched_spectrum, spectrum_sample_file)
def effect(self):
image_node = None
for node in self.svg.selected.values():
if (common.is_image(node)):
image_node = node
if image_node is not None:
image = common.prep_image(image_node)
image = image.convert('L')
data = pattern(image)
image = Image.fromarray(data)
image = image.convert('RGB')
common.save_image(image_node, image, img_format='PNG')
def effect(self):
image_node = None
for node in self.svg.selected.values():
if (common.is_image(node)):
image_node = node
if image_node is not None:
image = common.prep_image(image_node)
cmyk = gcr(image, 0)
dots = halftone(image, cmyk, 10, 1)
image = Image.merge('CMYK', dots)
image = image.convert('RGB')
common.save_image(image_node, image, img_format='PNG')
def effect(self):
image_node = None
for node in self.selected.values():
if(common.is_image(node)):
image_node = node
if image_node is not None:
image = common.prep_image(image_node)
image = image.convert('CMYK')
image = image.split()
for channel in image:
error_dispersion(channel.load(), channel.size)
image = Image.merge("CMYK", image).convert("RGB")
common.save_image(image_node, image, img_format='PNG')
def save_data(self, x, name, save_dir, x_is_real_x=False):
"""Save dataspace instances.
Args:
x: A numpy array of dataspace points.
name: A string indicating the name in the saved file.
save_dir: A string indicating the directory to put the saved file.
x_is_real_x: An boolean indicating whether `x` is already in dataspace. If
not, `x` is converted to dataspace before saving
"""
real_x = x if x_is_real_x else self.decode(x)
real_x = common.post_proc(real_x, self.config)
batched_real_x = common.batch_image(real_x)
sample_file = join(save_dir, '%s.png' % name)
common.save_image(batched_real_x, sample_file)
break
if diff[depth] < diff[data_min]:
data_min = depth
return data_min
(left_min, left_max) = calculate_min_max(left)
(right_min, right_max) = calculate_min_max(right)
# 扫描像素
for row_pos in range(len(left)):
# 读入图像
row_left = left[row_pos]
row_right = right[row_pos]
# 读入行
row_left_min = left_min[row_pos]
row_left_max = left_max[row_pos]
row_right_min = right_min[row_pos]
row_right_max = right_max[row_pos]
for pixel_pos in range(len(row_left)):
depth = calculate_diff_bt((row_left, row_left_min, row_left_max), (row_right, row_right_min, row_right_max),
pixel_pos)
my_result[row_pos][pixel_pos] = depth * 255 / 10
data_set['my_result_4'] = my_result
save_image(my_result, 'pixel bt method')
show_image(data_set)
if __name__ == '__main__':
# calculate_min_max(left)
pass
left = data_set['left']
right = data_set['right']
result = data_set['result']
import time
window_size = 5
d_max = 32
tt = time.time()
stereo = StereoVisionBM_SGM(left, right, window_size, d_max)
stereo.low_texture_detection()
stereo.compute_cost()
stereo.aggregate_cost()
my_result = stereo.get_result()
diff_result = stereo.left_right_check()
diff_result = diff_result * (255.0 / d_max / 16)
data_set['diff_result'] = diff_result
post_result = stereo.post_processing()
post_result = post_result * (255.0 / d_max / 16)
data_set['post_result'] = post_result
print time.time() - tt
my_result = my_result * (255.0 / d_max / 16)
data_set['my_result_sgm'] = my_result
show_image(data_set)
save_image(my_result, 'window method sgm')
save_image(post_result, 'window method sgm post')
# 统计结果 最后一个最小的视差
min_d_last = np.argmin(cost[-1])
self.my_result[row][-1] = min_d_last
min_d = min_d_last
for column in range(self.column_length - 1, 0, -1):
self.my_result[row][column - 1] = result_array[column][min_d]
min_d = result_array[column][min_d]
return self.my_result.copy()
if __name__ == '__main__':
data_set = get_data_set(0)
# get data
left = data_set['left']
right = data_set['right']
result = data_set['result']
import time
window_size = 5
d_max = 20
tt = time.time()
stereo = StereoVisionBM_DP_BT2(left, right, window_size, d_max)
stereo.compute_cost()
stereo.aggregate_cost()
my_result = stereo.get_result()
my_result = my_result * 255 / d_max
data_set['my_result_bt_dp2'] = my_result
print time.time() - tt
show_image(data_set)
save_image(my_result, 'window method BT DP 2')
data_set = get_data_set(0)
# get data
left = data_set['left']
right = data_set['right']
result = data_set['result']
import time
window_size = 5
d_max = 15
tt = time.time()
stereo = StereoVisionBM1(left, right, window_size, d_max)
'''
stereo.get_sad_all()
my_result = stereo.get_result()
my_result = my_result * 255 / d_max
data_set['my_result_6'] = my_result
print time.time() - tt
save_image(my_result, 'window method 6')
show_image(data_set)'''
data_set = get_data_set(0, is_color=True)
left = data_set['left']
right = data_set['right']
result = data_set['result']
stereo = StereoVisionBM1(left, right, window_size, d_max, is_color=True)
stereo.get_sad_all()
my_result = stereo.get_result()
my_result = my_result * 255 / d_max
data_set['my_result_6'] = my_result
show_image(data_set, is_color=True)
save_image(my_result, 'window method 6')
def main(unused_argv):
# pylint:disable=unused-variable
# Reason:
# This training script relys on many programmatical call to function and
# access to variables. Pylint cannot infer this case so it emits false alarm
# of unused-variable if we do not disable this warning.
# pylint:disable=invalid-name
# Reason:
# Following variables have their name consider to be invalid by pylint so
# we disable the warning.
# - Variable that in its name has A or B indictating their belonging of
# one side of data.
del unused_argv
# Load main config
config_name = FLAGS.config
config = load_config(config_name)
config_name_A = config['config_A']
config_name_B = config['config_B']
config_name_classifier_A = config['config_classifier_A']
config_name_classifier_B = config['config_classifier_B']
# Load dataset
dataset_A = common_joint.load_dataset(config_name_A, FLAGS.exp_uid_A)
(dataset_blob_A, train_data_A, train_label_A, train_mu_A, train_sigma_A,
index_grouped_by_label_A) = dataset_A
dataset_B = common_joint.load_dataset(config_name_B, FLAGS.exp_uid_B)
(dataset_blob_B, train_data_B, train_label_B, train_mu_B, train_sigma_B,
index_grouped_by_label_B) = dataset_B
# Prepare directories
dirs = common_joint.prepare_dirs('joint', config_name, FLAGS.exp_uid)
save_dir, sample_dir = dirs
# Set random seed
np.random.seed(FLAGS.random_seed)
tf.set_random_seed(FLAGS.random_seed)
# Real Training.
tf.reset_default_graph()
sess = tf.Session()
# Load model's architecture (= build)
one_side_helper_A = common_joint.OneSideHelper(config_name_A,
FLAGS.exp_uid_A,
config_name_classifier_A,
FLAGS.exp_uid_classifier)
one_side_helper_B = common_joint.OneSideHelper(config_name_B,
FLAGS.exp_uid_B,
config_name_classifier_B,
FLAGS.exp_uid_classifier)
m = common_joint.load_model(model_joint.Model, config_name, FLAGS.exp_uid)
# Initialize and restore
sess.run(tf.global_variables_initializer())
one_side_helper_A.restore(dataset_blob_A)
one_side_helper_B.restore(dataset_blob_B)
# Restore from ckpt
config_name = FLAGS.config
model_uid = common.get_model_uid(config_name, FLAGS.exp_uid)
save_name = join(save_dir,
'transfer_%s_%d.ckpt' % (model_uid, FLAGS.load_ckpt_iter))
m.vae_saver.restore(sess, save_name)
# prepare intepolate dir
intepolate_dir = join(sample_dir, 'interpolate_sample',
'%010d' % FLAGS.load_ckpt_iter)
tf.gfile.MakeDirs(intepolate_dir)
# things
interpolate_labels = [int(_) for _ in FLAGS.interpolate_labels.split(',')]
nb_images_between_labels = FLAGS.nb_images_between_labels
index_list_A = []
last_pos = [0] * 10
for label in interpolate_labels:
index_list_A.append(index_grouped_by_label_A[label][last_pos[label]])
last_pos[label] += 1
index_list_B = []
last_pos = [-1] * 10
for label in interpolate_labels:
index_list_B.append(index_grouped_by_label_B[label][last_pos[label]])
last_pos[label] -= 1
z_A = []
z_A.append(train_mu_A[index_list_A[0]])
for i_label in range(1, len(interpolate_labels)):
last_z_A = z_A[-1]
this_z_A = train_mu_A[index_list_A[i_label]]
for j in range(1, nb_images_between_labels + 1):
z_A.append(last_z_A + (this_z_A - last_z_A) *
(float(j) / nb_images_between_labels))
z_B = []
z_B.append(train_mu_B[index_list_B[0]])
for i_label in range(1, len(interpolate_labels)):
last_z_B = z_B[-1]
this_z_B = train_mu_B[index_list_B[i_label]]
for j in range(1, nb_images_between_labels + 1):
z_B.append(last_z_B + (this_z_B - last_z_B) *
(float(j) / nb_images_between_labels))
z_B_tr = []
for this_z_A in z_A:
this_z_B_tr = sess.run(m.x_A_to_B_direct,
{m.x_A: np.array([this_z_A])})
z_B_tr.append(this_z_B_tr[0])
# Generate data domain instances and save.
z_A = np.array(z_A)
x_A = one_side_helper_A.m_helper.decode(z_A)
x_A = common.post_proc(x_A, one_side_helper_A.m_helper.config)
batched_x_A = common.batch_image(
x_A,
max_images=len(x_A),
rows=len(x_A),
cols=1,
)
common.save_image(batched_x_A, join(intepolate_dir, 'x_A.png'))
z_B = np.array(z_B)
x_B = one_side_helper_B.m_helper.decode(z_B)
x_B = common.post_proc(x_B, one_side_helper_B.m_helper.config)
batched_x_B = common.batch_image(
x_B,
max_images=len(x_B),
rows=len(x_B),
cols=1,
)
common.save_image(batched_x_B, join(intepolate_dir, 'x_B.png'))
z_B_tr = np.array(z_B_tr)
x_B_tr = one_side_helper_B.m_helper.decode(z_B_tr)
x_B_tr = common.post_proc(x_B_tr, one_side_helper_B.m_helper.config)
batched_x_B_tr = common.batch_image(
x_B_tr,
max_images=len(x_B_tr),
rows=len(x_B_tr),
cols=1,
)
common.save_image(batched_x_B_tr, join(intepolate_dir, 'x_B_tr.png'))
if diff[depth] < diff[data_min]:
data_min = depth
return data_min
(left_min, left_max) = calculate_min_max(left)
(right_min, right_max) = calculate_min_max(right)
# 扫描像素
for row_pos in range(len(left)):
# 读入图像
row_left = left[row_pos]
row_right = right[row_pos]
# 读入行
row_left_min = left_min[row_pos]
row_left_max = left_max[row_pos]
row_right_min = right_min[row_pos]
row_right_max = right_max[row_pos]
for pixel_pos in range(len(row_left)):
depth = calculate_diff_bt((row_left, row_left_min, row_left_max),
(row_right, row_right_min, row_right_max),
pixel_pos)
my_result[row_pos][pixel_pos] = depth * 255 / 10
data_set['my_result_4'] = my_result
save_image(my_result, 'pixel bt method')
show_image(data_set)
if __name__ == '__main__':
# calculate_min_max(left)
pass
data_set['low_texture_row'] = low_texture_row
data_set['low_texture_column'] = low_texture_column
stereo.compute_cost()
t_diff = stereo.aggregate_cost()
my_result = stereo.get_result()
my_result = my_result * (255.0 / d_max / 16)
data_set['my_result_7'] = my_result
diff_result = stereo.left_right_check()
diff_result = diff_result * (255.0 / d_max / 16)
data_set['diff_result'] = diff_result
post_result = stereo.post_processing()
post_result = post_result * (255.0 / d_max / 16)
data_set['post_result'] = post_result
post_result2 = stereo.fix_low_texture()
post_result2 = post_result2 * (255.0 / d_max / 16)
post_result2 = filters.median_filter(post_result2, 5)
data_set['post_result2'] = post_result2
print time.time() - tt
show_image(data_set)
save_image(diff_result, 'diff_result')
save_image(post_result, 'post_result')
save_image(post_result2, 'post_result_2')
save_image(low_texture_column, 'low_texture_column')
save_image(low_texture_row, 'low_texture_row')
save_image(my_result, 'window method 7')
stereo.compute_cost()
stereo.aggregate_cost()
my_result = stereo.get_result()
diff_result = stereo.left_right_check()
post_result = stereo.post_processing()
# post_result2 = stereo.fix_low_texture()
print "use time:", time.time() - tt
data_set['low_texture'] = low_texture
my_result = my_result * (255.0 / d_max / 16)
data_set['my_result_ensus_bm'] = my_result
diff_result = diff_result * (255.0 / d_max / 16)
data_set['diff_result'] = diff_result
post_result = post_result * (255.0 / d_max / 16)
data_set['post_result'] = post_result
# post_result2 = post_result2 * (255.0 / d_max / 16)
# data_set['post_result2'] = post_result2
show_image(data_set)
save_image(my_result, 'window method Census BM')
save_image(diff_result, 'window method Census BM diff_result')
save_image(post_result, 'window method Census BM post_result')
# save_image(post_result2, 'window method Census BM post_result2')
stereo.compute_cost()
stereo.aggregate_cost()
my_result = stereo.get_result()
diff_result = stereo.left_right_check()
post_result = stereo.post_processing()
# post_result2 = stereo.fix_low_texture()
print "use time:", time.time() - tt
data_set['low_texture'] = low_texture
my_result = my_result * (255.0 / d_max / 16)
data_set['my_result_ensus_bm'] = my_result
diff_result = diff_result * (255.0 / d_max / 16)
data_set['diff_result'] = diff_result
post_result = post_result * (255.0 / d_max / 16)
data_set['post_result'] = post_result
# post_result2 = post_result2 * (255.0 / d_max / 16)
# data_set['post_result2'] = post_result2
show_image(data_set)
save_image(my_result, 'window method Census BM')
save_image(diff_result, 'window method Census BM diff_result')
save_image(post_result, 'window method Census BM post_result')
# save_image(post_result2, 'window method Census BM post_result2')
left = data_set['left']
right = data_set['right']
result = data_set['result']
import time
window_size = 5
d_max = 32
tt = time.time()
stereo = StereoVisionBM_SGM(left, right, window_size, d_max)
stereo.low_texture_detection()
stereo.compute_cost()
stereo.aggregate_cost()
my_result = stereo.get_result()
diff_result = stereo.left_right_check()
diff_result = diff_result * (255.0 / d_max / 16)
data_set['diff_result'] = diff_result
post_result = stereo.post_processing()
post_result = post_result * (255.0 / d_max / 16)
data_set['post_result'] = post_result
print time.time() - tt
my_result = my_result * (255.0 / d_max / 16)
data_set['my_result_sgm'] = my_result
show_image(data_set)
save_image(my_result, 'window method sgm')
save_image(post_result, 'window method sgm post')
'''reverse = self.get_result_reverse()
up = self.get_result_up()
down = self.get_result_down()
for row in np.arange(self.row_length):
for column in np.arange(self.column_length):
self.my_result[row][column] = np.median(
(reverse[row][column], forward[row][column], down[row][column], up[row][column]))
return self.my_result.copy()'''
if __name__ == '__main__':
data_set = get_data_set(0)
# get data
left = data_set['left']
right = data_set['right']
result = data_set['result']
import time
window_size = 5
d_max = 20
tt = time.time()
stereo = StereoVisionBM_DP(left, right, window_size, d_max)
stereo.compute_cost()
stereo.aggregate_cost()
my_result = stereo.get_result()
my_result = my_result * 255 / d_max
data_set['my_result_dp'] = my_result
show_image(data_set)
print time.time() - tt
save_image(my_result, 'window method DP')
diff_result = stereo.left_right_check()
post_result = stereo.post_processing()
# post_result2 = stereo.fix_low_texture()
print "use time:", time.time() - tt
data_set['low_texture'] = low_texture
data_set['left_c'] = left_c
data_set['right_c'] = right_c
my_result = my_result * (255.0 / d_max / 16)
data_set['my_result_ensus_bm'] = my_result
diff_result = diff_result * (255.0 / d_max / 16)
data_set['diff_result'] = diff_result
post_result = post_result * (255.0 / d_max / 16)
data_set['post_result'] = post_result
# post_result2 = post_result2 * (255.0 / d_max / 16)
# data_set['post_result2'] = post_result2
show_image(data_set)
save_image(left_c,'window method low texture BM left_c')
save_image(right_c,'window method low texture BM right_c')
save_image(my_result, 'window method low texture BM')
save_image(diff_result, 'window method low texture BM diff_result')
save_image(post_result, 'window method low texture BM post_result')
# save_image(post_result2, 'window method Census BM post_result2')
:param d_max:最大深度
:return:视差值
"""
start_pos = (pixel_pos - d_max) if (pixel_pos - d_max) > 0 else 0
row_right = row_right[start_pos:pixel_pos]
diff = map(lambda value: abs(value - pixel_value), row_right)
diff = diff[::-1] # 逆序
data_min = 0
for depth in range(len(diff)):
if diff[data_min] == 0:
break
if diff[depth] < diff[data_min]:
data_min = depth
return data_min
# 扫描像素
for row_pos in range(len(left)):
row_left = left[row_pos]
row_right = right[row_pos]
for pixel_pos in range(len(row_left)):
pixel = row_left[pixel_pos]
depth = calculate_diff_naive(pixel, row_right, pixel_pos)
my_result[row_pos][pixel_pos] = depth * 255 / 10
data_set['my_result'] = my_result
show_image(data_set)
save_image(my_result, 'pixel naive method')
if __name__ == '__main__':
pass
def main(unused_argv):
del unused_argv
# Load Config
config_name = FLAGS.config
config_module = importlib.import_module('configs.%s' % config_name)
config = config_module.config
model_uid = common.get_model_uid(config_name, FLAGS.exp_uid)
n_latent = config['n_latent']
# Load dataset
dataset = common.load_dataset(config)
basepath = dataset.basepath
save_path = dataset.save_path
train_data = dataset.train_data
# Make the directory
save_dir = os.path.join(save_path, model_uid)
best_dir = os.path.join(save_dir, 'best')
tf.gfile.MakeDirs(save_dir)
tf.gfile.MakeDirs(best_dir)
tf.logging.info('Save Dir: %s', save_dir)
# Set random seed
np.random.seed(FLAGS.random_seed)
tf.set_random_seed(FLAGS.random_seed)
# Load Model
tf.reset_default_graph()
sess = tf.Session()
with tf.device(tf.train.replica_device_setter(ps_tasks=0)):
m = model_dataspace.Model(config, name=model_uid)
_ = m() # noqa
# Initialize
sess.run(tf.global_variables_initializer())
# Load
m.vae_saver.restore(
sess, os.path.join(best_dir, 'vae_best_%s.ckpt' % model_uid))
# Sample from prior
sample_count = 64
image_path = os.path.join(basepath, 'sample', model_uid)
tf.gfile.MakeDirs(image_path)
# from prior
z_p = np.random.randn(sample_count, m.n_latent)
x_p = sess.run(m.x_mean, {m.z: z_p})
x_p = common.post_proc(x_p, config)
common.save_image(common.batch_image(x_p),
os.path.join(image_path, 'sample_prior.png'))
# Sample from priro, as Grid
boundary = 2.0
number_grid = 50
blob = common.make_grid(boundary=boundary,
number_grid=number_grid,
dim_latent=n_latent)
z_grid, dim_grid = blob.z_grid, blob.dim_grid
x_grid = sess.run(m.x_mean, {m.z: z_grid})
x_grid = common.post_proc(x_grid, config)
batch_image_grid = common.make_batch_image_grid(dim_grid, number_grid)
common.save_image(batch_image_grid(x_grid),
os.path.join(image_path, 'sample_grid.png'))
# Reconstruction
sample_count = 64
x_real = train_data[:sample_count]
mu, sigma = sess.run([m.mu, m.sigma], {m.x: x_real})
x_rec = sess.run(m.x_mean, {m.mu: mu, m.sigma: sigma})
x_rec = common.post_proc(x_rec, config)
x_real = common.post_proc(x_real, config)
common.save_image(common.batch_image(x_real),
os.path.join(image_path, 'image_real.png'))
common.save_image(common.batch_image(x_rec),
os.path.join(image_path, 'image_rec.png'))
def scrape_parks():
if (len(sys.argv) == 2):
if sys.argv[1] == 'mk':
print("getting mk")
get_streetview_in_bounding_box(28.42, -81.586220, 28.422,
-81.577347)
if sys.argv[1] == 'epcot':
print("getting epcot")
get_streetview_in_bounding_box(28.371, -81.553664, 28.377229,
-81.545482)
if sys.argv[1] == 'dhs':
print("getting dhs")
get_streetview_in_bounding_box(28.358, -81.563629, 28.361727,
-81.556257)
if sys.argv[1] == 'ak':
print("getting ak")
get_streetview_in_bounding_box(28.358, -81.594788, 28.3639,
-81.586140)
else:
parks = [
'regions/epcot/park.csv', 'regions/hollywood_studios/park.csv',
'regions/animal_kingdom/park.csv'
]
#parks = ['regions/animal_kingdom/park.csv']
num = 0
for csv_path in parks:
print(csv_path)
coords = []
with open(csv_path, "r") as f:
for line in f.readlines():
coords.append([
float(line.split(",")[i])
for i in range(len(line.split(",")))
])
coords = np.array(coords)
max_lat = "{:.3f}".format(max(coords[:, 0]))
max_long = "{:.3f}".format(max(coords[:, 1]))
min_lat = "{:.3f}".format(min(coords[:, 0]))
min_long = "{:.3f}".format(min(coords[:, 1]))
flickr = flickrapi.FlickrAPI(api_key,
api_secret,
format='parsed-json')
bbox_coords = [min_long, min_lat, max_long, max_lat]
print(bbox_coords)
for page in range(8, 10):
print("page " + str(page))
photos_search = flickr.photos.search(
bbox=",".join(bbox_coords),
min_upload_date=1524009600,
page=page)
assert (photos_search['stat'] == 'ok')
photos = photos_search['photos']['photo']
for im in photos:
common.save_image(im['id'], "Medium", "data")
print(num)
num += 1
data_set['low_texture_row'] = low_texture_row
data_set['low_texture_column'] = low_texture_column
stereo.compute_cost()
t_diff = stereo.aggregate_cost()
my_result = stereo.get_result()
my_result = my_result * (255.0 / d_max / 16)
data_set['my_result_7'] = my_result
diff_result = stereo.left_right_check()
diff_result = diff_result * (255.0 / d_max / 16)
data_set['diff_result'] = diff_result
post_result = stereo.post_processing()
post_result = post_result * (255.0 / d_max / 16)
data_set['post_result'] = post_result
post_result2 = stereo.fix_low_texture()
post_result2 = post_result2 * (255.0 / d_max / 16)
post_result2 = filters.median_filter(post_result2,5)
data_set['post_result2'] = post_result2
print time.time() - tt
show_image(data_set)
save_image(diff_result, 'diff_result')
save_image(post_result, 'post_result')
save_image(post_result2, 'post_result_2')
save_image(low_texture_column, 'low_texture_column')
save_image(low_texture_row, 'low_texture_row')
save_image(my_result, 'window method 7')
