def download_by_keyword(word_, base_dir, num_images):
urls = build_urls(word_)
base_dir = mk_dir(os.path.join(base_dir, word_))
if len(images_in_dir(base_dir)) > 0:
print('Has downloaded of {} '.format(word_))
return
idx = 0
print('==' * 20, word_, '==' * 20)
for url in urls:
print("正在请求：", url)
content = requests.get(url, timeout=10).content
try:
html = content.decode('utf-8')
except Exception:
html = content.decode('ISO-8859-1')
img_urls = resolve_image_url(html)
if len(img_urls) == 0:
break
for uri in img_urls:
suffix_name = '{0:04d}'.format(idx)
image_name = '{}_{}.{}'.format(word_, suffix_name, 'jpg')
idx += 1
if download(uri, base_dir, image_name):
print("{}, 已下载 {} 张".format(word_, idx))
else:
break
if idx >= num_images or idx > 9999:
break
if idx >= num_images:
print('您一共下载了{}, {} 张图片'.format(word_, idx))
break
def main(samples_dir, output_dir, image_size=160, margin=32):
hierarchy = read_from_hierarchy(samples_dir)
for k in hierarchy.keys():
images_path = hierarchy[k]
image_files = images_in_dir(images_path)
subdir = _subdir(output_dir, k)
start = time.time()
for im_f in image_files:
im = cv2.imread(im_f)
height, width = im.shape[:2]
faces = detect_faces(im)
print('{}, {} faces detected'.format(im_f, len(faces)))
for face in faces:
images_count = len(glob.glob('{}/*.jpg'.format(subdir)))
f_name = '{}_{}.jpg'.format(k, '{0:04d}'.format(images_count))
output_path = os.path.join(subdir, f_name)
x1, y1, x2, y2 = to_rectangle(face)
x1 = max(x1 - margin, 0)
y1 = max(y1 - margin, 0)
x2 = min(x2 + margin, width)
y2 = min(y2 + margin, height)
roi = im[y1:y2, x1:x2, :]
roi = cv2.resize(roi, (image_size, image_size))
cv2.imwrite(output_path, roi)
print('{} done, time spent: {}'.format(k, time.time() - start))
def main(samples_dir, test_images_dir, output_dir):
face_descriptors, class_names = load_samples_descriptors(samples_dir)
# save2pickle(face_descriptors, class_names, 'wg_merged.pkl')
# face_descriptors, class_names = load_from_pickle('wg_merged.pkl')
print(class_names)
labels, names = _labeled(class_names)
classifier = SVMClassifier()
print([names[i] for i in labels])
classifier.train(face_descriptors, labels, names)
# classifier.load("classifier_2018-05-15 13:30:06.213832.pkl")
image_files = images_in_dir(test_images_dir)
for im_f in image_files:
output_path = os.path.join(output_dir, filename(im_f))
im = cv2.imread(im_f)
faces = detect_faces(im)
for face in faces:
descriptor = compute_face_descriptor(im, face)
results = classifier.predict([descriptor])
for r in results:
txt = '{}'.format(r)
put_text(im, txt, font_face=cv2.FONT_HERSHEY_SIMPLEX)
print('{}: {} '.format(im_f, r))
cv2.imwrite(output_path, im)
def main(samples_dir, test_dir, output_dir):
face_descriptors, class_names = load_samples_descriptors(samples_dir)
save2pickle(face_descriptors, class_names, "wg_colleagues.pkl")
# face_descriptors, class_names = load_from_pickle('wg_colleagues.pkl')
print(face_descriptors[0])
print("len face_descriptors: {}".format(len(face_descriptors)))
print("len class_names: {}".format(len(class_names)))
print("class_names: {}".format(class_names))
print("total class: {}".format(len(set(class_names))))
image_files = images_in_dir(test_dir)
for im_f in image_files:
im = cv2.imread(im_f)
faces = detect_faces(im)
start = time.time()
for face in faces:
descriptor = compute_face_descriptor(im, face)
idx, distance = closest_one(face_descriptors, descriptor)
if distance > 0.4:
label = 'unknown'
else:
label = class_names[idx]
subdir = _subdir(output_dir, label)
images_count = len(glob.glob('{}/*.jpg'.format(subdir)))
f_name = '{}_{}.jpg'.format(label, '{0:04d}'.format(images_count))
print('{}: {}, of distance :{} '.format(im_f, f_name, distance))
output_path = os.path.join(subdir, f_name)
cv2.imwrite(output_path, im)
print('time : ', time.time() - start)
def main(samples_dir, test_dir, output_dir):
face_descriptors, class_names = load_samples_descriptors(samples_dir)
# save2pickle(face_descriptors, class_names, "wg_colleagues.pkl")
# face_descriptors, class_names = load_from_pickle('wg_colleagues.pkl')
image_files = images_in_dir(test_dir)
labels, names = _labeled(class_names)
classifier = SVMClassifier()
classifier.train(face_descriptors, labels, names)
for im_f in image_files:
f_name = filename(im_f)
im = cv2.imread(im_f)
faces = detect_faces(im)
start = time.time()
print('{} faces detected'.format(len(faces)))
for face in faces:
descriptor = compute_face_descriptor(im, face)
results = classifier.predict([descriptor])
for r in results:
label = '{}'.format(r)
print('label:', label)
subdir = _subdir(output_dir, label)
images_count = len(glob.glob('{}/*.jpg'.format(subdir)))
f_name = '{}_{}.jpg'.format(label,
'{0:04d}'.format(images_count))
output_path = os.path.join(subdir, f_name)
cv2.imwrite(output_path, im)
print('{} done, time spent: {}'.format(f_name, time.time() - start))
def resize(in_dir, out_dir, dsize):
img_files = images_in_dir(in_dir)
for img in img_files:
f_name = fname(img, without_ext=False)
image_path = os.path.join(out_dir, f_name)
im = cv2.imread(img)
resized = cv2.resize(im, dsize)
cv2.imwrite(image_path, resized)
print('{} done.'.format(img))
print("All done, {} images.".format(len(img_files)))
def predict(images_dir):
if not os.path.exists(OUTPUT_DIR):
os.makedirs(OUTPUT_DIR)
image_files = images_in_dir(images_dir)
for im_f in image_files:
f_name = filename(im_f)
im = cv2.imread(im_f)
face = extract(im_f)
results = find_top_n_closest(face)
im = overlay(im, results)
cv2.imwrite(os.path.join(OUTPUT_DIR, f_name), im)
def images2video(images_dir, fps, output_video_path):
from img_utils.files import images_in_dir
image_files = images_in_dir(images_dir)
if len(image_files) > 0:
im = cv2.imread(image_files[0])
height, width, _ = im.shape
fourcc = cv2.VideoWriter_fourcc(*'mp4v') # Be sure to use lower case
out = cv2.VideoWriter(output_video_path, fourcc, fps, (width, height))
for im_f in image_files:
im = cv2.imread(im_f)
out.write(im)
out.release()
def main(images_dir, output_dir):
image_files = images_in_dir(images_dir=images_dir)
for im_f in image_files:
im = cv2.imread(im_f)
start = time.time()
faces = detect_faces(im)
end = time.time()
print('{}: {}'.format(im_f, end - start))
for face in faces:
x1, y1, x2, y2 = to_rectangle(face)
cv2.rectangle(im, (x1, y1), (x2, y2), (0, 255, 0), 2)
cv2.imwrite(os.path.join(output_dir, filename(im_f)), im)
def read_known_persons_from_hierarchical_images(images_dir):
im_hierarchy = read_from_hierarchy(images_dir)
known_person = KnownPerson()
for k in im_hierarchy.keys():
im_dir = im_hierarchy[k]
im_files = images_in_dir(images_dir=im_dir)
features = []
for im_f in im_files:
face = extract(im_f)
features.append(extract_feature(face))
known_person.add_person(k, features)
known_person.save('known_person.pkl')
return known_person
def load_samples_descriptors(samples_dir):
"""
:param samples_dir: images dir which is organized as below
samples_dir/
├── Ariel_Sharon
│ ├── Ariel_Sharon_0006.png
│ ├── Ariel_Sharon_0007.png
│ ├── Ariel_Sharon_0008.png
│ ├── Ariel_Sharon_0009.png
│ └── Ariel_Sharon_0010.png
|
├── Arnold_Schwarzenegger
│ ├── Arnold_Schwarzenegger_0006.png
│ ├── Arnold_Schwarzenegger_0007.png
│ ├── Arnold_Schwarzenegger_0008.png
│ ├── Arnold_Schwarzenegger_0009.png
│ └── Arnold_Schwarzenegger_0010.png
|
├── Colin_Powell
│ ├── Colin_Powell_0006.png
│ ├── Colin_Powell_0007.png
:return: two lists, one for face encodings, one for corresponding class names
"""
images_dict = read_from_hierarchy(images_dir=samples_dir)
print(len(images_dict), images_dict)
class_names = []
face_descriptors = []
for k in images_dict.keys():
images_dir = images_dict[k]
image_files = images_in_dir(images_dir)
print('{}: {}'.format(k, image_files))
for im_f in image_files:
im = cv2.imread(im_f)
faces = detect_faces(im)
for face in faces:
descriptor = compute_face_descriptor(im, face)
face_descriptors.append(descriptor)
class_names.append(k)
return face_descriptors, class_names
def main(samples_dir, test_dir, output_dir):
# face_descriptors, class_names = load_samples_descriptors(samples_dir)
# save2pickle(face_descriptors, class_names, "wg_colleagues.pkl")
face_descriptors, class_names = load_from_pickle('../wg_colleagues.pkl')
print(face_descriptors[0])
print("len face_descriptors: {}".format(len(face_descriptors)))
print("len class_names: {}".format(len(class_names)))
print("class_names: {}".format(class_names))
image_files = images_in_dir(test_dir)
f_nums = {}
for im_f in image_files:
f_name = filename(im_f)
im = cv2.imread(im_f)
faces = detect_faces(im)
start = time.time()
for face in faces:
descriptor = compute_face_descriptor(im, face)
idx, distance = closest_one(face_descriptors, descriptor)
#
# f_num = len(glob.glob('{}/{}*.jpg'.format(output_dir, class_names[idx])))
# f_name = '{}_{}.jpg'.format(class_names[idx], '{0:04d}'.format(f_num))
#
f_nums.setdefault(
class_names[idx],
len(
glob.glob('{}/{}*.jpg'.format(output_dir,
class_names[idx]))))
f_name = '{}_{}.jpg'.format(
class_names[idx], '{0:04d}'.format(f_nums[class_names[idx]]))
f_nums[class_names[idx]] += 1
# txt = '{}:{}'.format(class_names[idx], distance)
# put_text(im, txt, font_face=cv2.FONT_HERSHEY_SIMPLEX)
print('{}: {}, of distance :{} '.format(im_f, f_name, distance))
end = time.time()
print('time : ', end - start)
output_path = os.path.join(output_dir, f_name)
cv2.imwrite(output_path, im)
def main(samples_dir, test_dir, output_dir):
# face_descriptors, class_names = load_samples_descriptors(samples_dir)
# save2pickle(face_descriptors, class_names, "wg_colleagues.pkl")
face_descriptors, class_names = load_from_pickle('wg_colleagues.pkl')
print(face_descriptors[0])
print("len face_descriptors: {}".format(len(face_descriptors)))
print("len class_names: {}".format(len(class_names)))
print("class_names: {}".format(class_names))
image_files = images_in_dir(test_dir)
for im_f in image_files:
output_path = os.path.join(output_dir, filename(im_f))
im = cv2.imread(im_f)
faces = detect_faces(im)
for face in faces:
descriptor = compute_face_descriptor(im, face)
idx, distance = closest_one(face_descriptors, descriptor)
txt = '{}:{}'.format(class_names[idx], distance)
put_text(im, txt, font_face=cv2.FONT_HERSHEY_SIMPLEX)
print('{}: {}, of distance :{} '.format(im_f, class_names[idx],
distance))
cv2.imwrite(output_path, im)
def main(samples_dir, validate_data_dir, output_dir):
classifier_file = "classifier_wgers_160_2018-06-14.pkl"
classifier = SVMClassifier(probability=False)
if classifier_file is None:
face_descriptors, class_names = load_samples_descriptors(samples_dir)
print("len face_descriptors: {}".format(len(face_descriptors)))
print("len class_names: {}".format(len(class_names)))
print("class_names: {}".format(class_names))
print("class_names: {}".format(class_names))
print("total class: {}".format(len(set(class_names))))
labels, names = _labeled(class_names)
print([names[i] for i in labels])
classifier.train(face_descriptors, labels, names)
else:
classifier.load(classifier_file)
hierarchy = read_from_hierarchy(validate_data_dir)
total = 0
accurate = 0
time_spent = 0
for k in hierarchy.keys():
image_files = images_in_dir(hierarchy[k])
total += len(image_files)
for im_f in image_files:
im = cv2.imread(im_f)
# faces = detect_faces(im)
height, width = im.shape[:2]
faces = rect_2_dlib_rectangles((0, 0), (width, height))
a, t = _evaluate_with_classifier(im, faces, classifier, k, output_dir)
accurate += a
time_spent += t
print("-------------------------------------Accuracy is: {} ".format(accurate / total))
print('==================================================================')
print('Accurate is {}, total: {}'.format(accurate, total))
print('Total time spent is: {}'.format(time_spent))
print("Average time spent is: {}".format(time_spent / total))
print("Average Accuracy is: {} ".format(accurate / total))
def batch(image_dir, output_dir):
image_files = images_in_dir(image_dir)
for image_file in image_files:
process_one_image(image_file, output_dir)
# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-i",
"--images_dir",
required=True,
help="Directories of the images")
ap.add_argument("-o",
"--output_dir",
required=True,
help="Directories of output")
args = vars(ap.parse_args())
images_dir = args['images_dir']
output_dir = args['output_dir']
all_images = images_in_dir(images_dir)
all_images = sorted(all_images)
images = iter(all_images)
cv2.namedWindow("Label", cv2.WINDOW_AUTOSIZE)
cv2.setMouseCallback("Label", click_and_crop)
raw_image, img_file = _next()
image = raw_image.copy()
while True:
try:
cv2.setWindowTitle("Label", img_file)
cv2.imshow("Label", image)
except StopIteration as e:
_save_result()
break
args = parser.parse_args()
input_images = args.images
outputs = args.output
keras_weights_file = args.model
print('start processing...')
# load model
# authors of original model don't use
# vgg normalization (subtracting mean) on input images
model = get_testing_model()
model.load_weights(keras_weights_file)
# load config
params, model_params = config_reader()
print('params:\n {}'.format(params))
print('model_params:\n {}'.format(model_params))
# generate image with body parts
image_files = images_in_dir(input_images)
for im_f in image_files:
tic = time.time()
canvas = process(im_f, params, model_params)
toc = time.time()
print('processing time is %.5f' % (toc - tic))
cv2.imwrite(os.path.join(outputs, filename(im_f)), canvas)
cv2.destroyAllWindows()
fshift = np.fft.fftshift(f)
# rows, cols = image.shape[:2]
# crow, ccol = rows // 2, cols // 2
# fshift[crow - 50:crow + 50, ccol - 50:ccol + 50] = 0
# fshift[:, :] = 0
f_ishift = np.fft.ifftshift(fshift)
img_back = np.fft.ifft2(f_ishift)
img_back = np.abs(img_back)
print(img_back.var())
# cv2.imshow('im', img_back)
# cv2.waitKey(0)
return True, img_back.var()
if __name__ == '__main__':
args = sys.argv
images_dir = args[1]
output_dir = args[2]
image_files = images_in_dir(images_dir)
for im_f in image_files:
im = cv2.imread(im_f)
print(im_f)
gray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
cv2.G
blurred, lap = fft(gray)
img = put_text(im, 'B: {}'.format(blurred), (10, 20))
img = put_text(img, 'L: {}'.format(lap), (10, 40))
cv2.imwrite(os.path.join(output_dir, im_f.split(os.sep)[-1]), img)