for i in `ls ${1}| head -n 3500`
do
mv ${1}/$i ./temp_datas
done
import os
from PIL import Image
def get_file_paths(folder):
image_file_paths = []
for root, dirs, filenames in os.walk(folder):
filenames = sorted(filenames)
for filename in filenames:
input_path = os.path.abspath(root)
file_path = os.path.join(input_path, filename)
if filename.endswith('.png') or filename.endswith('.jpg'):
image_file_paths.append(file_path)
break # prevent descending into subfolders
return image_file_paths
def align_images(a_file_paths, b_file_paths, target_path):
if not os.path.exists(target_path):
os.makedirs(target_path)
for i in range(len(a_file_paths)):
img_a = Image.open(a_file_paths[i])
img_b = Image.open(b_file_paths[i])
assert(img_a.size == img_b.size)
aligned_image = Image.new("RGB", (img_a.size[0] * 2, img_a.size[1]))
aligned_image.paste(img_a, (0, 0))
aligned_image.paste(img_b, (img_a.size[0], 0))
aligned_image.save(os.path.join(target_path, '{:04d}.jpg'.format(i)))
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser()
parser.add_argument(
'--dataset-path',
dest='dataset_path',
help='Which folder to process (it should have subfolders testA, testB, trainA and trainB'
)
args = parser.parse_args()
dataset_folder = args.dataset_path
print(dataset_folder)
test_a_path = os.path.join(dataset_folder, 'testA')
test_b_path = os.path.join(dataset_folder, 'testB')
test_a_file_paths = get_file_paths(test_a_path)
test_b_file_paths = get_file_paths(test_b_path)
assert(len(test_a_file_paths) == len(test_b_file_paths))
test_path = os.path.join(dataset_folder, 'test')
train_a_path = os.path.join(dataset_folder, 'trainA')
train_b_path = os.path.join(dataset_folder, 'trainB')
train_a_file_paths = get_file_paths(train_a_path)
train_b_file_paths = get_file_paths(train_b_path)
assert(len(train_a_file_paths) == len(train_b_file_paths))
train_path = os.path.join(dataset_folder, 'train')
align_images(test_a_file_paths, test_b_file_paths, test_path)
align_images(train_a_file_paths, train_b_file_paths, train_path)
import os
from PIL import Image
def get_file_paths(folder):
image_file_paths = []
for root, dirs, filenames in os.walk(folder):
filenames = sorted(filenames)
for filename in filenames:
input_path = os.path.abspath(root)
file_path = os.path.join(input_path, filename)
if filename.endswith('.png') or filename.endswith('.jpg'):
image_file_paths.append(file_path)
break # prevent descending into subfolders
return image_file_paths
def align_images(a_file_paths, b_file_paths, target_path):
if not os.path.exists(target_path):
os.makedirs(target_path)
for i in range(len(a_file_paths)):
img_a = Image.open(a_file_paths[i])
img_b = Image.open(b_file_paths[i])
assert(img_a.size == img_b.size)
aligned_image = Image.new("RGB", (img_a.size[0] * 2, img_a.size[1]))
aligned_image.paste(img_a, (0, 0))
aligned_image.paste(img_b, (img_a.size[0], 0))
aligned_image.save(os.path.join(target_path, '{:04d}.jpg'.format(i)))
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser()
parser.add_argument(
'--dataset-path',
dest='dataset_path',
help='Which folder to process (it should have subfolders trainA and trainB'
)
args = parser.parse_args()
dataset_folder = args.dataset_path
print(dataset_folder)
train_a_path = os.path.join(dataset_folder, 'trainA')
train_b_path = os.path.join(dataset_folder, 'trainB')
train_a_file_paths = get_file_paths(train_a_path)
train_b_file_paths = get_file_paths(train_b_path)
assert(len(train_a_file_paths) == len(train_b_file_paths))
train_path = os.path.join(dataset_folder, 'train')
align_images(train_a_file_paths, train_b_file_paths, train_path)
import numpy as np
import cv2
import time
import os
import random
import sys
import threading
import multiprocessing
import urllib
import warnings
from multiprocessing import Lock
warnings.filterwarnings("ignore")
def convert2Sketch( img, white_threshold ):
scope = 255 / (255-white_threshold)
b = -scope * white_threshold
# print(img.shape, scope, b)
[m,n,c] = img.shape
# Remove colors
if c > 1:
temp_img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
else:
temp_img_gray = img
img_gray = [temp_img_gray,temp_img_gray,temp_img_gray]
img_gray = np.array(img_gray).transpose((1,2,0))
img_gray[img_gray <= white_threshold] = 0
img_gray[img_gray > white_threshold] = scope * img_gray[img_gray > white_threshold] + b;
img_gray[img_gray > 255 - white_threshold] = 255 - white_threshold
img_gray2 = 255 - img_gray
radius = 1;
img_gray2 = min_filter(img_gray2, radius);
img_mix = color_dodge(img_gray2, img_gray);
res = np.array(img_mix).astype(np.uint8);
return res
def color_dodge(layer1, layer2):
# print(layer2.dtype)
layer3 = layer1.copy()
layer3[layer2 < 255] = np.clip(layer1[layer2 < 255] / (255 - layer2[layer2 < 255]) * 256, 0 , 255)
layer3[layer2 >= 255] = 255
return layer3
# Function for min filter
def min_filter(img, radius):
kernel = np.ones((1 + 2 *radius,1 + 2 *radius),np.uint8)
erosion = cv2.erode(img,kernel,iterations = 1)
return erosion
# Function for min filter
def max_filter(img, radius):
kernel = np.ones((1 + 2 *radius,1 + 2 *radius),np.uint8)
erosion = cv2.dilate(img,kernel,iterations = 1)
return erosion
def get_image_url(index, index2, index3, line, input_filename,output_filename ):
try:
try:
lock = Lock()
lock.acquire()
img = cv2.imread(input_filename)
img = np.array(np.array(img).astype(np.float64) * 1.5).astype(np.uint8);
white_threshold = 40;
img_res = convert2Sketch(img, white_threshold);
cv2.imwrite(output_filename,img_res)
except Exception as e:
print(e, index, index2, index3, line)
finally:
lock.release()
except Exception as e:
pass
finally:
pass
def running_processing(index, index2, lines, input_filename,output_filename):
threads = []
for index3, line in enumerate(lines) :
print("--------------------------line------------------------------",index, index2, index3, line)
t = threading.Thread(target= get_image_url, args=(index, index2, index3, line, input_filename[index3], output_filename[index3]))
threads.append(t)
for index_i, thread in enumerate(threads):
# thread.setDaemon(True)
thread.start()
for index_j, thread in enumerate(threads):
thread.join()
if __name__ == "__main__":
Threads_number = 10
Processes_number = 4
input_path = sys.argv[1]
output_path = input_path + "output"
if not os.path.exists(output_path):
os.makedirs(output_path)
index = 0
temp_lines = []
file_name_list = []
output_file_name_list = []
all_temp_lines = []
all_file_name_list = []
all_output_file_name_list = []
all_lines = os.listdir(input_path)
len_all_lines = len(all_lines)
for index,line in enumerate(all_lines):
try:
file_name = input_path + "/" + line
output_file_name = output_path + "/" + line
temp_lines.append(line)
file_name_list.append(file_name)
output_file_name_list.append(output_file_name)
if len(temp_lines) % Threads_number == 0 or len_all_lines == (index + 1):
all_temp_lines.append(temp_lines)
all_file_name_list.append(file_name_list)
all_output_file_name_list.append(output_file_name_list)
if len(all_temp_lines) % Processes_number == 0 or len_all_lines == (index + 1):
# print("len(temp_lines)", len(temp_lines))
# print("len(all_temp_lines)", len(all_temp_lines))
multiThreads = []
for index2, value in enumerate(all_temp_lines):
mt = multiprocessing.Process(target=running_processing,args=(index, index2, all_temp_lines[index2], all_file_name_list[index2], all_output_file_name_list[index2]))
mt.start()
multiThreads.append(mt)
for mthread in multiThreads:
mthread.join()
all_temp_lines = []
all_file_name_list = []
all_output_file_name_list = []
temp_lines = []
file_name_list = []
output_file_name_list = []
except Exception as e:
print(e,line)(cycleGAN)
import os
import numpy as np
import cv2
import argparse
parser = argparse.ArgumentParser('create image pairs')
parser.add_argument('--fold_A', dest='fold_A', help='input directory for image A', type=str, default='../dataset/50kshoes_edges')
parser.add_argument('--fold_B', dest='fold_B', help='input directory for image B', type=str, default='../dataset/50kshoes_jpg')
parser.add_argument('--fold_AB', dest='fold_AB', help='output directory', type=str, default='../dataset/test_AB')
parser.add_argument('--num_imgs', dest='num_imgs', help='number of images',type=int, default=1000000)
parser.add_argument('--use_AB', dest='use_AB', help='if true: (0001_A, 0001_B) to (0001_AB)',action='store_true')
args = parser.parse_args()
for arg in vars(args):
print('[%s] = ' % arg, getattr(args, arg))
splits = os.listdir(args.fold_A)
for sp in splits:
img_fold_A = os.path.join(args.fold_A, sp)
img_fold_B = os.path.join(args.fold_B, sp)
img_list = os.listdir(img_fold_A)
if args.use_AB:
img_list = [img_path for img_path in img_list if '_A.' in img_path]
num_imgs = min(args.num_imgs, len(img_list))
print('split = %s, use %d/%d images' % (sp, num_imgs, len(img_list)))
img_fold_AB = os.path.join(args.fold_AB, sp)
if not os.path.isdir(img_fold_AB):
os.makedirs(img_fold_AB)
print('split = %s, number of images = %d' % (sp, num_imgs))
for n in range(num_imgs):
name_A = img_list[n]
path_A = os.path.join(img_fold_A, name_A)
if args.use_AB:
name_B = name_A.replace('_A.', '_B.')
else:
name_B = name_A
path_B = os.path.join(img_fold_B, name_B)
if os.path.isfile(path_A) and os.path.isfile(path_B):
name_AB = name_A
if args.use_AB:
name_AB = name_AB.replace('_A.', '.') # remove _A
path_AB = os.path.join(img_fold_AB, name_AB)
im_A = cv2.imread(path_A, cv2.CV_LOAD_IMAGE_COLOR)
im_B = cv2.imread(path_B, cv2.CV_LOAD_IMAGE_COLOR)
im_AB = np.concatenate([im_A, im_B], 1)
cv2.imwrite(path_AB, im_AB)
