def __getitem__(self, idx):
clean_fn = random.choice(self.clean_fns[idx])
clean_img = read_img(clean_fn)
noise_img = read_img(clean_fn.replace('GT_SRGB', 'NOISY_SRGB'))
if self.patch_size > 0:
[clean_img, noise_img] = get_patch([clean_img, noise_img],
self.patch_size)
return hwc_to_chw(noise_img), hwc_to_chw(clean_img), np.zeros(
(3, self.patch_size, self.patch_size)), np.zeros(
(3, self.patch_size, self.patch_size))
def __getitem__(self, idx):
clean_fn = random.choice(self.clean_fns[idx])
clean_img = read_img(clean_fn)
noise_img = read_img(clean_fn.replace('GT_SRGB', 'NOISY_SRGB'))
if self.patch_size > 0:
clean_img, noise_img = get_patch(clean_img, noise_img,
self.patch_size)
clean_img_chw = hwc_to_chw(clean_img)
noise_img_chw = hwc_to_chw(noise_img)
return noise_img_chw, clean_img_chw
def __getitem__(self, idx):
clean_fn = random.choice(self.clean_fns[idx])
clean_img = read_img(clean_fn)
noise_img = read_img(clean_fn.replace('GT_SRGB', 'NOISY_SRGB'))
sigma_img = read_img(clean_fn.replace(
'GT_SRGB', 'SIGMA_SRGB')) / 15. # inverse scaling
if self.patch_size > 0:
[clean_img, noise_img,
sigma_img] = get_patch([clean_img, noise_img, sigma_img],
self.patch_size)
return hwc_to_chw(noise_img), hwc_to_chw(clean_img), hwc_to_chw(
sigma_img), np.ones((3, self.patch_size, self.patch_size))
def __getitem__(self, idx): if not len(self.origin_imgs[idx]): origin_img = read_img(self.filenames[idx]) if not (len(self.sigma_s) and len(self.sigma_c)): # all random min_log = np.log([0.000001]) sigma_s = min_log + np.random.rand(1) * (np.log([0.002]) - min_log) sigma_s = np.exp(sigma_s) sigma_c = min_log + np.random.rand(1) * (np.log([0.001]) - min_log) sigma_c = np.exp(sigma_c) else: sigma_s = self.sigma_s sigma_c = self.sigma_c self.origin_imgs[idx], self.noise_imgs[idx] = self.isp.cbdnet_noise_generate_srgb(origin_img, sigma_s, sigma_c) origin_img = self.origin_imgs[idx] noise_img = self.noise_imgs[idx] patch_origin_img, patch_noise_img = get_patch(origin_img, noise_img, self.patch_size, self.random) patch_origin_img_chw = hwc_to_chw(patch_origin_img) patch_noise_img_chw = hwc_to_chw(patch_noise_img) return patch_noise_img_chw, patch_origin_img_chw
def inference(model_path, img_id):
model = load_model(model_path)
img = read_img(img_id)
normalized = normalize_img(img)
repeats_x = math.ceil(img.shape[0] / INPUT_SIZE)
repeats_y = math.ceil(img.shape[1] / INPUT_SIZE)
input_shape = (1, INPUT_SIZE, INPUT_SIZE, img.shape[2])
result = np.zeros((img.shape[0], img.shape[1], len(CLASSES)))
for idx_x in range(repeats_x):
for idx_y in range(repeats_y):
s_x = idx_x * INPUT_SIZE
s_y = idx_y * INPUT_SIZE
patch = normalized[s_x:s_x + INPUT_SIZE, s_y:s_y + INPUT_SIZE]
input_img = np.zeros(input_shape)
input_img[0, 0:patch.shape[0], 0:patch.shape[1]] = patch
pred = model.predict(input_img)
result[s_x:s_x + patch.shape[0], s_y:s_y + patch.shape[1]] \
= pred[0, 0:patch.shape[0], 0:patch.shape[1]]
result = np.where(result > INFERENCE_THRESHOLD, 1, 0)
return result
def main(flags):
model = flags.model
image = flags.image
saver = tf.train.import_meta_graph(model + ".meta")
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.InteractiveSession(config=config)
saver.restore(sess, model)
X, mode = tf.get_collection("inputs")
pred = tf.get_collection("outputs")[0]
print('loading image')
proj, geotrans, input_img = read_img(image)
input_img = input_img[:, :, :3]
input_img = np.asarray(input_img, dtype='uint8')
label_pred = predict_img_with_smooth_windowing(
input_img,
window_size=256,
subdivisions=2,
batch_size=256,
pred_func=(
lambda img: sess.run(pred, feed_dict={X: img, mode: False})
)
)
label_pred = label_pred[:, :, 0]
label_pred[np.where(label_pred >= 0.5)] = 1
label_pred[np.where(label_pred < 0.5)] = 0
label_pred = label_pred.astype(np.uint8)
prd_name = "%s_%s_m%s_prd.tif" % (image[:-4], model.split('/')[0], model[-7:-5])
write_img(prd_name, proj, geotrans, label_pred)
def create_data_record(out_filename, images_addrs, labels_addrs):
# open the TFRecords file
writer = tf.python_io.TFRecordWriter(out_filename)
for i in range(len(images_addrs)):
# print how many images are saved every 100 images
if i % 100==0:
print('Train data: {}/{}'.format(i, len(images_addrs)))
sys.stdout.flush()
# Load the image
img = read_img(images_addrs[i])
label = read_label(labels_addrs[i])
if img is None or label is None:
print("erroe null image")
continue
# Create a feature
feature = {
'image_raw': _bytes_feature(img.tostring()),
'label': _bytes_feature(label.tostring())
}
# Create an example protocol buffer
example = tf.train.Example(features=tf.train.Features(feature=feature))
# Serialize to string and write on the file
writer.write(example.SerializeToString())
writer.close()
sys.stdout.flush()
def smart_split_img_at_middle_by_x_axis(img_path, resize_radio=0.1):
im_raw = utils.read_img(img_path)
im_resize = utils.resize_by_percent(im_raw, resize_radio)
bin_img = utils.rgb2binary(im_resize)
ry, rx = bin_img.shape
img_mtx0 = np.asarray(bin_img)
y_sum_array0 = img_mtx0.sum(axis=0) # y轴求和
subtracts_arr = np.abs(array_latter_subtracts_precious(y_sum_array0 /
ry)) # 长度减1
subtracts_arr_index = np.argsort(subtracts_arr,
kind='quicksort',
order=None)
subtracts_arr_index = subtracts_arr_index[-10:]
index_middle_distance_list = list(np.abs(subtracts_arr_index -
int(rx / 2)))
split_index = subtracts_arr_index[index_middle_distance_list.index(
min(index_middle_distance_list))] + 1
split_index = int(split_index / resize_radio)
img_left, img_right = split_by_index(im_raw, split_index)
left_path = img_path.replace('.jpg', '_left.jpg')
right_path = img_path.replace('.jpg', '_right.jpg')
cv2.imencode('.jpg', img_left)[1].tofile(left_path)
cv2.imencode('.jpg', img_right)[1].tofile(right_path)
print(left_path)
print(right_path)
def __getitem__(self, index):
img_id = self.imgs[index]
img = read_img(self.root / img_id)
mask = np.zeros_like(img)[..., [0]]
return dev_transform(img, mask)[0], img_id
def get_residual_map(img_path, cfg):
test_img = read_img(img_path, cfg.grayscale)
if test_img.shape[:2] != (cfg.im_resize, cfg.im_resize):
test_img = cv2.resize(test_img, (cfg.im_resize, cfg.im_resize))
test_img_ = test_img / 255.
if test_img.shape[:2] == (cfg.patch_size, cfg.patch_size):
test_img_ = np.expand_dims(test_img_, 0)
decoded_img = autoencoder.predict(test_img_)
else:
patches = get_patch(test_img_, cfg.patch_size, cfg.stride)
patches = autoencoder.predict(patches)
decoded_img = patch2img(patches, cfg.im_resize, cfg.patch_size,
cfg.stride)
rec_img = np.reshape((decoded_img * 255.).astype('uint8'), test_img.shape)
if cfg.grayscale:
ssim_residual_map = 1 - ssim(
test_img, rec_img, win_size=cfg.ssim_win_size, full=True)[1]
l1_residual_map = np.abs(test_img / 255. - rec_img / 255.)
else:
ssim_residual_map = ssim(test_img,
rec_img,
win_size=cfg.ssim_win_size,
full=True,
multichannel=True)[1]
ssim_residual_map = 1 - np.mean(ssim_residual_map, axis=2)
l1_residual_map = np.mean(np.abs(test_img / 255. - rec_img / 255.),
axis=2)
return test_img, rec_img, ssim_residual_map, l1_residual_map
def super_resolution_(LR_path, model_list, out_dir):
LR_arr3d = read_img(LR_path)
nrow = LR_arr3d.shape[0]
ncol = LR_arr3d.shape[1]
xs = np.repeat(list(range(nrow)), ncol)
ys = np.array(list(range(ncol)) * nrow)
coordinates = pd.DataFrame({'x': xs, 'y': ys})
feat_mat = coordinates.apply(get_feature_helper,
LR_array3d=LR_arr3d,
axis=1)
feat_mat = np.dstack(feat_mat).transpose(
2, 0, 1) # shape = (nrow * ncol, 8, 3)
pred_mat = np.empty((nrow * ncol, 4, 3))
for i in range(12):
pred_mat[:, i % 4,
i // 4] = model_list[i].predict(feat_mat[:, :, i // 4])
HR_array3d = reshape_helper(nrow, ncol, pred_mat)
LR_arr3d_resize = np.apply_along_axis(np.repeat, 1, LR_arr3d, 2)
LR_arr3d_resize = np.apply_along_axis(np.repeat, 0, LR_arr3d_resize, 2)
HR_array3d = HR_array3d + LR_arr3d_resize
HR_array3d = HR_array3d.astype('uint8')
HR_img = Image.fromarray(HR_array3d)
HR_img.save(out_dir)
def __getitem__(self, idx):
batch_x = self.filenames[idx * self.batch_size:(idx + 1) *
self.batch_size]
batch_x = np.array(
[read_img(filename, self.grayscale) for filename in batch_x])
batch_x = batch_x / 255.
return batch_x, batch_x
def make_forward_scanner(dset_name, data_dir, input_spec, scan_spec,
scan_params, **params):
""" Creates a DataProvider ForwardScanner from a dset name """
# Reading lightsheet image
if os.path.isfile(os.path.join(data_dir, dset_name + "_img.h5")):
img = utils.read_img(os.path.join(data_dir, dset_name + "_img.h5"))
elif os.path.isfile(os.path.join(data_dir, dset_name + "_img.tif")):
img = utils.read_img(os.path.join(data_dir, dset_name + "_img.tif"))
img = (img / 255.).astype("float32")
# Creating DataProvider Dataset
vd = dp.Dataset(spec=input_spec)
vd.add_data(key="input", data=img)
# Returning DataProvider ForwardScanner
return dp.ForwardScanner(vd, scan_spec, **scan_params)
def get_train_data(train_img_ids, df, gs):
x_train_list = []
y_train_list = []
for img_id in train_img_ids:
img = read_img(img_id)
x_train = normalize_img(img)
y_train = generate_mask(x_train, img_id, df, gs)
x_train_list.append(x_train)
y_train_list.append(y_train)
return (x_train_list, y_train_list)
def __getitem__(self, idx): batch_path = os.path.join(self.root_dir, self.batches[idx]) if not len(self.origin_imgs[idx]): origin_fns = glob.glob(batch_path + '/Reference.png') noise_fns = glob.glob(batch_path + '/Noisy.png') self.origin_imgs[idx] = read_img(origin_fns[0]) for noise_fn in noise_fns: self.noise_imgs[idx].append(read_img(noise_fn)) origin_img = self.origin_imgs[idx] noise_img = self.noise_imgs[idx][np.random.randint(len(self.noise_imgs[idx]))] patch_origin_img, patch_noise_img = get_patch(origin_img, noise_img, self.patch_size, self.random) patch_origin_img_chw = hwc_to_chw(patch_origin_img) patch_noise_img_chw = hwc_to_chw(patch_noise_img) return patch_noise_img_chw, patch_origin_img_chw
def vgg19_test():
vgg19 = VGG19('data/checkpoints/vgg_19.ckpt')
inputs = tf.placeholder(tf.float32, [None, 224, 224, 3])
vgg19.build_model(inputs, is_train=False)
test_img_path = 'data/test_imgs/ILSVRC2012_val_00000003.JPEG'
test_img = utils.read_img(test_img_path, expand_dims=True)
sess = tf.Session()
sess.run(tf.global_variables_initializer())
output = sess.run(vgg19.fc8, feed_dict={inputs: test_img})
prob_lable = int(np.argmax(output, axis=1))
print(prob_lable, utils.get_class_name_by_id(prob_lable))
def get_polygons_list(img_id, df, gs):
img = read_img(img_id)
x_scaler, y_scaler = get_img_scalers(img, img_id, gs)
polygons_list = []
for class_type in range(1, len(CLASSES) + 1):
polygons = get_polygons(img_id, class_type, df)
polygons = affinity.scale(polygons,
xfact=x_scaler,
yfact=y_scaler,
origin=(0, 0, 0))
polygons_list.append(polygons)
return polygons_list
def generator(samples, batch_size=1, augment_data=True):
num_samples = len(samples)
while 1: # Loop forever so the generator never terminates
random.shuffle(samples)
for offset in range(0, num_samples, batch_size):
batch_samples = samples[offset:offset+batch_size]
images = []
y_train = []
for batch_sample in batch_samples:
name = batch_sample[0].split('/')[-1]
correction = 0
if augment_data and random.random() > 0.75: # Augment left / right camera
if random.random() > 0.5: # left
name = batch_sample[1].split('/')[-1]
correction = 0.2
else: # right
name = batch_sample[2].split('/')[-1]
correction = -0.2
filepath = os.path.join("/opt/test/drive2", "IMG", name)
assert os.path.isfile(filepath), "Is not path: {}".format(filepath)
center_image = utils.read_img(filepath)
center_angle = float(batch_sample[3]) # Steering
center_angle += correction
throttle = float(batch_sample[4])
brake = float(batch_sample[5])
speed = float(batch_sample[6])
if augment_data and random.random() > 0.5:
center_image = np.fliplr(center_image)
center_angle = - center_angle
images.append(center_image)
y_train.append([center_angle, throttle])
# trim image to only see section with road
X_train = np.array(images)
y_train = np.array(y_train)
y_train = y_train[:, 0]
#X_train = (X_train - mean) / std
# Reshape from BGR to RGB
#print(X_train.shape, IMAGE_MEAN.shape)
X_train = normalize_img(X_train)
#X_train = crop_images(X_train)
#print(X_train.shape)
yield sklearn.utils.shuffle(X_train, y_train)
def __getitem__(self, idx):
if torch.is_tensor(idx):
idx = idx.tolist()
img_name = self.allpaths[idx]
image = utils.read_img(img_name)
label = self.labels[idx]
if self.transform:
image = self.transform(image)
return (image, label)
# data = ConceptData("box_above", None)
# for ix in data :
# print (ix[1])
def split_img_at_middle_by_y_axis(img_path, radio=0.10, thresh_std=5000):
im_raw = utils.read_img(img_path)
im_resize = utils.resize_by_percent(im_raw, radio)
ry, rx, _ = im_resize.shape
img_mtx0 = np.asarray(utils.rgb2binary(im_resize))
y_sum_array0 = img_mtx0.sum(axis=0)
tmp = array_latter_subtracts_precious(y_sum_array0 / ry)
std0 = np.std(tmp) # 计算标准差
# # plt.bar(range(len(y_sum_array0)), y_sum_array0)
# # plt.show()
# plt.plot(range(len(y_sum_array0)-1), tmp)
# plt.show()
y, x, _z = im_resize.shape
x_bias = int(x * 0.15)
y_bias = int(y * 0.30)
middle_x = int(x / 2)
middle_area_img = im_resize[y_bias:y, middle_x - x_bias:middle_x + x_bias]
img_mtx = np.asarray(utils.rgb2binary(middle_area_img))
y_sum_array = img_mtx.sum(axis=0)
std = np.std(y_sum_array) # 计算标准差
y_sum_list = list(y_sum_array)
if std <= thresh_std:
index = y_sum_list.index(max(y_sum_list))
else:
index = y_sum_list.index(min(y_sum_list))
split_index = middle_x + index - int(len(y_sum_list) / 2)
split_index = int(split_index / radio)
y_raw, x_raw, _ = im_raw.shape
img_left = im_raw[1:y_raw, 1:split_index]
img_right = im_raw[1:y_raw, split_index + 1:x_raw]
left_path = img_path.replace('.jpg', '_left.jpg')
right_path = img_path.replace('.jpg', '_right.jpg')
cv2.imencode('.jpg', img_left)[1].tofile(left_path)
cv2.imencode('.jpg', img_right)[1].tofile(right_path)
print(left_path)
print(right_path)
def __getitem__(self, index):
item = self.df.iloc[index]
img = read_img(item.filename, page=self.config.train.page)
img, _ = get_tiles(
img,
tile_size=self.config.train.tile_size,
n_tiles=self.config.train.n_tiles,
mode=0,
)
img = concat_tiles(
img,
n_tiles=self.config.train.n_tiles,
image_size=self.config.train.image_size,
rand=self.is_train,
transform=self.transform,
)
img = to_tensor(img)
label = np.zeros(self.config.network.num_classes, dtype="float32")
label[:item[self.config.data.labels].values.argmax()] = 1.0
return img, torch.from_numpy(label)
def main(img_path, side_num):
img = read_img(img_path)
opened = pre_process(img)
# find poly or circle
if side_num == 0:
approx_contours = find_circle(img, opened)
else:
approx_contours = find_poly(img, opened, side_num=side_num) # temp
# find momentums
momentum_img = get_blank_img(img.shape)
cv2.drawContours(momentum_img, approx_contours, -1, (0, 0, 0), 2)
for contour in approx_contours:
center_x, center_y = get_momentum(contour)
print("x,y: {},{}".format(center_x, center_y))
cv2.circle(momentum_img, (center_x, center_y), 7, 128, -1) # 绘制中心点
# show result
show_img(momentum_img, 'momentums')
cv2.imwrite("./image/momentum.png", momentum_img)
cv2.waitKey(0)
cv2.destroyAllWindows()
def main(net, args):
img_path = args.image_path.replace("file://", "")
img_fn = img_path.split("/")[-1]
assert os.path.exists(img_path)
img_origin, h_origin, w_origin = read_img(img_path)
tmp_img = test_preprocess(img_origin, to_tensor=True,
pad=False).to(args.device)
net.eval()
torch.cuda.empty_cache()
gc.collect()
start = time.time()
with torch.no_grad():
preds = net(tmp_img)
print(">>> Inference took {}'s".format(time.time() - start))
if args.heatmap:
visualize_heatmap(args, img_fn, tmp_img, preds.to('cpu')[0].numpy())
else:
batch = {'shape': [(h_origin, w_origin)]}
visualize_polygon(args, img_fn, (img_origin, h_origin, w_origin),
batch, preds)
def train(self, img_dir, epochs, batch_size=64, save_interval=50):
# Load the dataset
X_train = utils.read_img(img_dir, with_resize=True)
# Rescale -1 to 1
X_train = X_train * 2 - 1.
# X_train = np.expand_dims(X_train, axis=3)
# Adversarial ground truths
valid = np.ones((batch_size, 1))
fake = np.zeros((batch_size, 1))
for epoch in range(epochs + 1):
idx = np.random.randint(0, X_train.shape[0], batch_size)
imgs = X_train[idx]
# Sample noise and generate a batch of new images
noise = np.random.normal(0, 1, (batch_size, self.len_z))
gen_imgs = self.generator.predict(noise)
# Train the discriminator (real classified as ones and generated as zeros)
d_loss_real = self.discriminator.train_on_batch(imgs, valid)
d_loss_fake = self.discriminator.train_on_batch(gen_imgs, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# Train the generator (wants discriminator to mistake images as real)
g_loss = self.combined.train_on_batch(noise, valid)
# Plot the progress
if epoch % save_interval == 0:
print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" %
(epoch // save_interval, d_loss[0], 100 * d_loss[1],
g_loss))
# If at save interval => save generated image samples
if epoch % save_interval == 0:
self.save_imgs(epoch)
outfile_path = args.out
content_image_path = args.input
gpu = args.gpu
if not args.ckpt and not args.mdl:
utils.fail('Please provide the folder path of either checkpoint or savedmodel')
if gpu > -1:
device = '/gpu:{}'.format(gpu)
else:
device = '/cpu:0'
if args.ckpt:
# Get the input shape
original_image = utils.read_img(content_image_path).astype(np.float32) / 255.0
shaped_input = original_image.reshape((1,) + original_image.shape)
with tf.device(device):
# Construct inference graph based on the input shape
inputs = tf.placeholder(tf.float32, shaped_input.shape, name='input')
net = stylenet.net(inputs)
saver = tf.train.Saver(restore_sequentially=True)
# Transfer image style
with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess:
input_checkpoint = tf.train.get_checkpoint_state(args.ckpt)
saver.restore(sess, input_checkpoint.model_checkpoint_path)
out = sess.run(net, feed_dict={inputs: shaped_input})
else:
with tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) as sess:
sc.addFile("/nfs/paper-big-data-engines/utils.py")
sc.addFile("/nfs/paper-big-data-engines/histogram/Histogram.py")
from utils import benchmark, crawl_dir, read_img
from Histogram import (
calculate_histogram,
combine_histogram,
flatten,
save_histogram,
)
print("Connected")
# Read images
paths = crawl_dir(os.path.abspath(args.bb_dir))
paths = sc.parallelize(paths, len(paths))
img_rdd = paths.map(lambda p: read_img(p, start=start, args=args))
img_rdd = img_rdd.map(
lambda x: flatten(x[1], start=start, args=args, filename=x[0]))
partial_histogram = img_rdd.map(lambda x: calculate_histogram(
x[1], args=args, start=start, filename=x[0]))
histogram = partial_histogram.fold(
np.array([0] * (2**16 - 1)),
lambda x, y: combine_histogram(x, y, args=args, start=start),
)
save_histogram(histogram, args=args, start=start)
# print(mn_idx)
# mn_img_tmp = utils.to_img(mn_img)
# utils.preview_img(mn_img_tmp)
new_img[r_idx:r_idx_lim, c_idx:c_idx_lim] = mn_img
gen_img = utils.to_img(new_img)
utils.write_img(out_img_path, gen_img)
# break
# break
gen_img = utils.to_img(new_img)
return gen_img
# ------------------------------------------------------------------------
img = utils.read_img(inp_img_path)
imgs = utils.read_small_imgs(assets_dir=assets_dir,
num=small_imgs_num,
format_str="{:05d}.png")
# indexes = []
# for i in range(64):
# indexes.append([np.random.randint(10000) for i in range(64)])
# imgt = utils.Image(imgs=imgs, index=indexes)
# img = imgt.construct_img()
# img = utils.to_img(img)
# print(img.size)
def helper(filename):
# from matplotlib import pyplot as plt
from utils import cv2, read_img
import subprocess
from gtts import gTTS
from playsound import playsound
max_val = 8
max_pt = -1
max_kp = 0
orb = cv2.ORB_create(nfeatures=2500)
# orb is an alternative to SIFT
#test_img = read_img('files/test_100_2.jpg')
#test_img = read_img('files/test_50_2.jpg')
#test_img = read_img('files/500test.jpg')
#test_img = read_img('files/test_100_3.jpg')
#test_img = read_img('files/10test.jpg')
test_img = read_img(filename)
# resizing must be dynamic
# original = resize_img(test_img, 0.4)
# display('original', original)
# keypoints and descriptors
# (kp1, des1) = orb.detectAndCompute(test_img, None)
(kp1, des1) = orb.detectAndCompute(test_img, None)
training_set = ['files/10.1.jpg','files/10.2.jpg','files/10.3.jpg','files/10.4.jpg','files/10.5.jpg','files/10.6.jpg','files/20.1.jpg','files/20.2.jpg','files/20.3.jpg','files/20.4.jpg','files/20.5.jpg','files/20.6.jpg','files/50.1.jpg','files/50.2.jpg','files/50.3.jpg','files/50.4.jpg','files/50.5.jpg','files/50.6.jpg','files/100.1.jpg','files/100.2.jpg','files/100.3.jpg','files/100.4.jpg','files/100.5.jpg','files/100.6.jpg','files/200.1.jpg','files/200.2.jpg','files/200.3.jpg','files/200.4.jpg','files/200.5.jpg','files/200.6.jpg','files/500.1.jpg','files/500.2.jpg','files/500.3.jpg','files/500.4.jpg','files/500.5.jpg','files/500.6.jpg','files/2000.1.jpg','files/2000.2.jpg','files/2000.3.jpg','files/2000.4.jpg','files/2000.5.jpg','files/2000.6.jpg','files/10.jpg','files/10_1.jpeg','files/10back.jpg','files/10_new.jpg','files/10_newback.jpg','files/20.jpg','files/20back.jpg','files/20_new.jpg' ,'files/20_newback.jpg','files/50.jpg','files/50back.jpg', 'files/50_new.jpg', 'files/50_newback.jpg','files/100.jpg','files/100back.jpg', 'files/100_new.jpg','files/100_newback.jpg','files/200.jpg','files/500.jpg','files/500back.jpg','files/500_1.jpg','files/500_2.jpg','files/2000.jpg','files/2000back.jpg', 'files/Rs200.jpg']
for i in range(0, len(training_set)):
# train image
train_img = cv2.imread(training_set[i])
(kp2, des2) = orb.detectAndCompute(train_img, None)
# brute force matcher
bf = cv2.BFMatcher()
all_matches = bf.knnMatch(des1, des2, k=2)
good = []
# give an arbitrary number -> 0.789
# if good -> append to list of good matches
for (m, n) in all_matches:
if m.distance < 0.789 * n.distance:
good.append([m])
if len(good) > max_val:
max_val = len(good)
max_pt = i
max_kp = kp2
print(i, ' ', training_set[i], ' ', len(good))
if max_val != 8:
print(training_set[max_pt])
print('good matches ', max_val)
train_img = cv2.imread(training_set[max_pt])
img3 = cv2.drawMatchesKnn(test_img, kp1, train_img, max_kp, good, 4)
note = str(training_set[max_pt])[6:-4]
print('\nDetected denomination: Rs. ', note)
audio_file = 'audio/' + note + '.mp3'
return note
else:
print('No Matches')
return "-1"
frame_dir = os.path.join(opts.data_dir, opts.phase, opts.method,
opts.task, opts.dataset, video)
occ_dir = os.path.join(opts.data_dir, opts.phase, "fw_occlusion",
opts.dataset, video)
flow_dir = os.path.join(opts.data_dir, opts.phase, "fw_flow",
opts.dataset, video)
frame_list = glob.glob(os.path.join(frame_dir, "*.jpg"))
err = 0
for t in range(1, len(frame_list)):
### load input images
filename = os.path.join(frame_dir, "%05d.jpg" % (t - 1))
img1 = utils.read_img(filename)
filename = os.path.join(frame_dir, "%05d.jpg" % (t))
img2 = utils.read_img(filename)
print("Evaluate Warping Error on %s-%s: video %d / %d, %s" %
(opts.dataset, opts.phase, v + 1, len(video_list), filename))
### load flow
filename = os.path.join(flow_dir, "%05d.flo" % (t - 1))
flow = utils.read_flo(filename)
### load occlusion mask
filename = os.path.join(occ_dir, "%05d.png" % (t - 1))
occ_mask = utils.read_img(filename)
noc_mask = 1 - occ_mask
input_dir = os.path.join(opts.data_dir, opts.phase, "input",
opts.dataset, video)
process_dir = os.path.join(opts.data_dir, opts.phase, "processed",
opts.task, opts.dataset, video)
output_dir = os.path.join(opts.data_dir, opts.phase, opts.method,
opts.task, opts.dataset, video)
frame_list = glob.glob(os.path.join(input_dir, "*.jpg"))
dist = 0
for t in range(1, len(frame_list)):
### load processed images
filename = os.path.join(process_dir, "%05d.jpg" % (t))
P = utils.read_img(filename)
### load output images
filename = os.path.join(output_dir, "%05d.jpg" % (t))
O = utils.read_img(filename)
print("Evaluate LPIPS on %s-%s: video %d / %d, %s" %
(opts.dataset, opts.phase, v + 1, len(video_list), filename))
### convert to tensor
P = utils.img2tensor(P)
O = utils.img2tensor(O)
### scale to [-1, 1]
P = P * 2.0 - 1
O = O * 2.0 - 1
