def dl_images(source_domain='stylebook.de',
text_filter='',
dl_dir='/data/jeremy/image_dbs/golden/',
in_docker=True,
visual_output=False):
'''
dl everything in the images db, on the assumption that these are the most relevant to test our answers to
:return:
'''
if in_docker:
db = pymongo.MongoClient('localhost', port=27017).mydb
else:
db = constants.db
all = db.images.find({'domain': source_domain})
for doc in all:
url = doc['image_urls'][0]
if text_filter in url[0]:
print url
Utils.get_cv2_img_array(url,
convert_url_to_local_filename=True,
download=True,
download_directory=dl_dir)
else:
print('skipping ' + url)
#move the images with more than one person
imutils.do_for_all_files_in_dir(imutils.one_person_per_image,
dl_dir,
visual_output=False)
def get_pd_results(url=None, filename=None, img_arr=None):
if url is not None:
print('getting pd results for ' + url)
image = Utils.get_cv2_img_array(url)
elif filename is not None:
print('getting pd results for ' + filename)
image = cv2.imread(filename)
elif img_arr is not None:
print('getting pd results for img_arr ')
image = img_arr
if image is None:
print('image came back none')
return None
try:
seg_res = pd_falcon_client.pd(image)
except:
print('exception in pd_falcon_client.pd ' + str(sys.exc_info()[0]))
return
# print('segres:'+str(seg_res))
if not 'mask' in seg_res:
print('pd did not return mask')
print seg_res
return
mask = seg_res['mask']
label_dict = seg_res['label_dict']
print('labels:' + str(label_dict))
# conversion_utils.count_values(mask)
pose = seg_res['pose']
mask_np = np.array(mask, dtype=np.uint8)
print('masksize ' + str(mask_np.shape))
pose_np = np.array(pose, dtype=np.uint8)
print('posesize ' + str(pose_np.shape))
return [mask, label_dict, pose_np]
def download_image(prod, feature_name, category_id, max_images):
downloaded_images = 0
directory = os.path.join(category_id, feature_name)
try:
downloaded_images = len([name for name in os.listdir(directory) if os.path.isfile(name)])
except:
pass
if downloaded_images < max_images:
xlarge_url = prod['image']['sizes']['XLarge']['url']
img_arr = Utils.get_cv2_img_array(xlarge_url)
if img_arr is None:
logging.warning("Could not download image at url: {0}".format(xlarge_url))
return
relevance = background_removal.image_is_relevant(img_arr)
if relevance.is_relevant:
logging.info("Image is relevant...")
filename = "{0}_{1}.jpg".format(feature_name, prod["id"])
filepath = os.path.join(directory, filename)
Utils.ensure_dir(directory)
logging.info("Attempting to save to {0}...".format(filepath))
success = cv2.imwrite(filepath, img_arr)
if not success:
logging.info("!!!!!COULD NOT SAVE IMAGE!!!!!")
return 0
# downloaded_images += 1
logging.info("Saved... Downloaded approx. {0} images in this category/feature combination"
.format(downloaded_images))
return 1
else:
# TODO: Count number of irrelevant images (for statistics)
return 0
def test_gender(self):
for url in self.urls:
img_arr = Utils.get_cv2_img_array(url)
if img_arr is None:
continue
print('image size:' + str(img_arr.shape))
face_dict = cropping.find_that_face(img_arr, 1)
face = face_dict['faces'][0]
print('face x,y,w,h: ' + str(face))
result = classifier_client.get('gender', url, url=url, face=face)
print('result for gender on {} is {}'.format(url, result))
def get_pd_results_and_save(url=None, filename=None):
if url is not None:
print('getting pd results for ' + url)
image = Utils.get_cv2_img_array(url)
elif filename is not None:
print('getting pd results for ' + filename)
image = cv2.imread(filename)
if image is None:
print('image came back none')
return None
try:
seg_res = pd_falcon_client.pd(image)
except:
print('exception in pd_falcon_client.pd ' + str(sys.exc_info()[0]))
return
# print('segres:'+str(seg_res))
if filename is not None:
imgfilename = os.path.basename(
filename
) #use the actual on-disk filename if thats what we started with, otherwise use the name generated by pd
#this will et saved to /home/jeremy/pd_output/filename
else:
try:
imgfilename = seg_res['filename'] + '.jpg'
except:
print('some error on imgfile name')
imgfilename = str(int(time.time())) + '.jpg'
print('filename ' + imgfilename)
if not 'mask' in seg_res:
print('pd did not return mask')
print seg_res
return
mask = seg_res['mask']
label_dict = seg_res['label_dict']
print('labels:' + str(label_dict))
conversion_utils.count_values(mask)
pose = seg_res['pose']
mask_np = np.array(mask, dtype=np.uint8)
print('masksize ' + str(mask_np.shape))
pose_np = np.array(pose, dtype=np.uint8)
print('posesize ' + str(pose_np.shape))
# print('returned url '+seg_res['url'])
converted_mask = convert_and_save_results(mask_np, label_dict, pose_np,
imgfilename, image, url)
dir = constants.pd_output_savedir
Utils.ensure_dir(dir)
full_name = os.path.join(dir, imgfilename)
# full_name = filename
bmp_name = full_name.strip('.jpg') + (
'.bmp') #this bmp should get generated by convert_and_save_results
# imutils.show_mask_with_labels(bmp_name,constants.fashionista_categories_augmented_zero_based,original_image = full_name,save_images=False)
return mask, label_dict, pose_np, converted_mask
def get_single_label_output(url_or_np_array,
required_image_size=(227, 227),
output_layer_name='prob'):
'''
CURRENTLY INOPERATIONAL
:param url_or_np_array:
:param required_image_size:
:param output_layer_name:
:return:
'''
if isinstance(url_or_np_array, basestring):
print('infer_one working on url:' + url_or_np_array)
image = Utils.get_cv2_img_array(url_or_np_array)
elif type(url_or_np_array) == np.ndarray:
image = url_or_np_array
# load image, switch to BGR, subtract mean, and make dims C x H x W for Caffe
# im = Image.open(imagename)
# im = im.resize(required_imagesize,Image.ANTIALIAS)
# in_ = in_.astype(float)
in_ = imutils.resize_keep_aspect(image,
output_size=required_image_size,
output_file=None)
in_ = np.array(in_, dtype=np.float32) #.astype(float)
if len(in_.shape) != 3: #h x w x channels, will be 2 if only h x w
print('got 1-chan image, turning into 3 channel')
#DEBUG THIS , ORDER MAY BE WRONG [what order? what was i thinking???]
in_ = np.array([in_, in_, in_])
elif in_.shape[
2] != 3: #for rgb/bgr, some imgages have 4 chan for alpha i guess
print('got n-chan image, skipping - shape:' + str(in_.shape))
return
# in_ = in_[:,:,::-1] for doing RGB -> BGR : since this is loaded nby cv2 its unecessary
# cv2.imshow('test',in_)
in_ -= np.array((104, 116, 122.0))
in_ = in_.transpose((2, 0, 1))
# shape for input (data blob is N x C x H x W), set data
multilabel_net.blobs['data'].reshape(1, *in_.shape)
multilabel_net.blobs['data'].data[...] = in_
# run net and take argmax for prediction
multilabel_net.forward()
# out = net.blobs['score'].data[0].argmax(axis=0) #for a parse with per-pixel max
out = multilabel_net.blobs[output_layer_name].data[
0] #for the nth class layer #siggy is after sigmoid
min = np.min(out)
max = np.max(out)
print('out {}'.format(out))
def create_training_set_with_grabcut(collection):
coll = db[collection]
i = 1
total = db.training_images.count()
start = time.time()
for doc in coll.find():
if not i % 10:
print "did {0}/{1} documents in {2} seconds".format(
i, total,
time.time() - start)
print "average time for image = {0}".format(
(time.time() - start) / i)
url = doc['url'].split('/')[-1]
img_url = 'https://tg-training.storage.googleapis.com/tamara_berg_street2shop_dataset/images/' + url
image = Utils.get_cv2_img_array(img_url)
if image is None:
print "{0} is a bad image".format(img_url)
continue
i += 1
small_image, ratio = background_removal.standard_resize(image, 600)
# skin_mask = kassper.skin_detection_with_grabcut(small_image, small_image, skin_or_clothes='skin')
# mask = np.where(skin_mask == 255, 35, 0).astype(np.uint8)
mask = np.zeros(small_image.shape[:2], dtype=np.uint8)
for item in doc['items']:
try:
bb = [int(c / ratio) for c in item['bb']]
item_bb = get_margined_bb(small_image, bb, 0)
if item['category'] not in cats:
continue
category_num = cats.index(item['category'])
item_mask = background_removal.simple_mask_grabcut(
small_image, rect=item_bb)
except:
continue
mask = np.where(item_mask == 255, category_num, mask)
filename = 'tamara_berg_street2shop_dataset/masks/' + url[:-4] + '.txt'
save_to_storage(bucket, mask, filename)
coll.update_one({'_id': doc['_id']}, {
'$set': {
'mask_url':
'https://tg-training.storage.googleapis.com/' + filename
}
})
print "Done masking! took {0} seconds".format(time.time() - start)
def make_masks(images):
img_arrs = []
masks = []
mask_items = []
for url1 in images:
max_retry = 5
got_mask = False
img_arr = Utils.get_cv2_img_array(url1)
while max_retry and not got_mask:
try:
mask, labels, pose = paperdoll_parse_enqueue.paperdoll_enqueue(
img_arr, at_front=True, async=False).result[:3]
got_mask = np.any(mask) # condition for legal mask?
print(str(got_mask))
masks.append(mask)
final_mask = paperdolls.after_pd_conclusions(
mask, labels) #, person['face'])
for num in np.unique(final_mask):
category = list(labels.keys())[list(
labels.values()).index(num)]
if category == 'dress' and category in constants.paperdoll_shopstyle_women.keys(
):
print("Found dress!!")
mask_item = 255 * np.array(final_mask == num,
dtype=np.uint8)
mask_items.append(mask_item)
except Exception as e:
max_retry = max_retry - 1
print("Failed to get mask with exception:")
print e.message
if not got_mask:
print url1 + " failed."
continue
else:
print "Success: " + url1
# np.save("yuli_masks.npy", masks)
# np.save(mfilename, mask_items)
return
def save_img_at_url(url,savename=None):
# download the image, convert it to a NumPy array, and then save
# it into OpenCV format using last part of url (will overwrite imgs of same name at different url)
if not savename:
savename = url.split('?')[0]
img_arr = Utils.get_cv2_img_array(url)
print('name:'+savename)
cv2.imwrite(savename,img_arr)
return img_arr
if url.count('jpg') > 1:
print('np jpg here captain')
return None
resp = requests.get(url)
print resp
# resp = urllib.urlopen(url)
image = np.asarray(bytearray(resp.read()), dtype="uint8")
if image.size == 0:
return None
new_image = cv2.imdecode(image, cv2.IMREAD_COLOR)
def get_hydra_output(url_or_image_arr,
out_dir='./',
orig_size=(256, 256),
crop_size=(224, 224),
mean=(104.0, 116.7, 122.7),
gpu=1,
save_data=True,
save_path='/data/jeremy/caffenets/hydra/production/saves',
detection_thresholds=constants.hydra_tg_thresholds,
url=None):
'''
start net, get a bunch of results. DONE: resize to e.g. 250x250 (whatever was done in training) and crop to dims
:param url_or_image_arr_list:#
:param prototxt:
:param caffemodel:
:param out_dir:
:param dims:
:param output_layers:
:param mean:
:return:
'''
detection_thresholds = None
start_time = time.time()
caffe.set_mode_gpu()
caffe.set_device(gpu)
# print('params:'+str(hydra_net.params))
out_layers = hydra_net.outputs
out_layers = put_in_numeric_not_alphabetic_order(out_layers)
# print('out layers: '+str(out_layers))
j = 0
output_names = constants.hydra_tg_heads
# load image, resize, crop, subtract mean, and make dims C x H x W for Caffe
im = Utils.get_cv2_img_array(url_or_image_arr)
if im is None:
logging.warning('could not get image ' + str(url_or_image_arr))
return None
if isinstance(url_or_image_arr, basestring):
print('get_hydra_output working on:' + url_or_image_arr)
print('img size:' + str(im.shape))
im = imutils.resize_keep_aspect(im, output_size=orig_size)
im = imutils.center_crop(im, crop_size)
in_ = np.array(im, dtype=np.float32)
if len(in_.shape) != 3:
print('got 1-chan image, skipping')
return
elif in_.shape[2] != 3:
print('got n-chan image, skipping - shape:' + str(in_.shape))
return
in_ -= mean
in_ = in_.transpose((2, 0, 1)) #W,H,C -> C,W,H
hydra_net.blobs['data'].reshape(1, *in_.shape)
hydra_net.blobs['data'].data[...] = in_
# run net and take argmax for prediction
hydra_net.forward()
out = {}
i = 0
for output_layer in out_layers:
one_out = hydra_net.blobs[output_layer].data[
0] #not sure why the data is nested [1xN] matrix and not a flat [N] vector
second_neuron = copy.copy(
one_out[1]
) #the copy is required - if you dont do it then out gets over-written with each new one_out
second_neuron = round(float(second_neuron), 3)
# print('type:'+str(type(second_neuron)))
name = output_names[i]
if detection_thresholds is None:
out[name] = second_neuron
print('{} for category {} {}'.format(second_neuron, i, name))
elif second_neuron > detection_thresholds[i]:
out[name] = second_neuron
print('{} is past threshold {} for category {} {}'.format(
second_neuron, detection_thresholds[i], i, name))
logging.debug('output for {} {} is {}'.format(output_layer, name,
second_neuron))
# print('final till now:'+str(all_outs)+' '+str(all_outs2))
i = i + 1
logging.debug('all output:' + str(out))
logging.debug('elapsed time:' + str(time.time() - start_time))
if save_data:
if isinstance(url_or_image_arr, basestring):
filename = url_or_image_arr.replace('https://', '').replace(
'http://', '').replace('/', '_')
url = url_or_image_arr
else:
n_chars = 6
filename = ''.join(
random.choice(string.ascii_uppercase + string.digits)
for _ in range(n_chars)) + '.jpg'
if url is None:
url = 'not_from_url'
Utils.ensure_dir(save_path)
imgname = os.path.join(save_path, filename)
if imgname[:-4] != '.jpg':
imgname = imgname + '.jpg'
cv2.imwrite(imgname, im)
# out['imgname']=filename
out['url'] = url
textfile = os.path.join(save_path, 'output.txt')
with open(textfile, 'a') as fp:
json.dump(out, fp, indent=4)
fp.close()
print('wrote image to {} and output text to {}'.format(
imgname, textfile))
return out
return mask #
if __name__ == "__main__":
urls = ['https://s-media-cache-ak0.pinimg.com/236x/ce/64/a0/ce64a0dca7ad6d609c635432e9ae1413.jpg', #bags
'http://pinmakeuptips.com/wp-content/uploads/2015/02/1.4.jpg',
'https://s-media-cache-ak0.pinimg.com/564x/9a/9d/f7/9a9df7455232035c6284ad1961816fd8.jpg',
'http://2.bp.blogspot.com/-VmiQlqdliyE/U9nyto2L1II/AAAAAAAADZ8/g30i4j_YZeI/s1600/310714+awayfromblue+kameleon+shades+chambray+shift+dress+converse+louis+vuitton+neverfull+mbmj+scarf.png',
'https://s-media-cache-ak0.pinimg.com/236x/1b/31/fd/1b31fd2182f0243ebc97ca115f04f131.jpg',
'http://healthsupporters.com/wp-content/uploads/2013/10/belt_2689094b.jpg' ,
'http://static1.businessinsider.com/image/53c96c90ecad04602086591e-480/man-fashion-jacket-fall-layers-belt.jpg', #belts
'http://gunbelts.com/media/wysiwyg/best-gun-belt-width.jpg',
'https://i.ytimg.com/vi/5-jWNWUQdFQ/maxresdefault.jpg'
]
start_time=time.time()
for url in urls:
image = Utils.get_cv2_img_array(url)
output = get_mlb_output(image)
# output = get_mlb_output(url)
# output1 = multilabel_from_binaries.get_multiple_single_label_outputs(url)
# output2 = multilabel_from_binaries2.get_multiple_single_label_outputs(url)
print('final output for {} : cat {} '.format(url,output))
# print('final output for {} : cat {} {}'.format(url,output1,output2))
elapsed_time = time.time()-start_time
print('time per image:{}, {} elapsed for {} images'.format(elapsed_time/len(urls),elapsed_time,len(urls)))
# cv2.imshow('output',output)
raw_input('ret to cont')
test_combine_neurodoll_and_multilabel(url)
raw_input('ret to cont')
test_combine_neurodoll_nonfalcon_and_multilabel_falcon(url)
import argparse
import glob
import time
counter = 0
ext = [".jpg", ".png"]
mother_path = '/home/jeremy/image_dbs/colorful_fashion_parsing_data'
sets = {'images', 'labels', 'labels_200x150'}
for set in sets:
path = os.path.join(mother_path, set)
for root, dirs, files in os.walk(path):
for file in files:
if file.endswith(tuple(ext)):
image = Utils.get_cv2_img_array(os.path.join(root, file))
mirrored_image = cv2.flip(image, 1)
words = file.split('.')
cv2.imwrite(
os.path.join(root,
str(words[0]) + '-mirrored.' + str(words[1])),
mirrored_image)
counter += 1
print counter
print os.path.join(root, words[0] + '-mirrored.' + words[1])
def check_db_speed(url, products_collection, category, annoy_list):
image = Utils.get_cv2_img_array(url)
if image is None:
print "Couldn't download image.."
return
mask = np.random.rand(image.shape[0], image.shape[1])
mask = np.where(mask < 0.1, 255, 0).astype(np.uint8)
start = time.time()
fp = fingerprint_core.dict_fp(image, mask, category)
# find_similar_mongo.find_top_n_results(image=image, mask=mask, number_of_results=100, category_id=category,
# collection=products_collection, dibi=db)
# entries = db[products_collection].find({'categories': category},
# {"id": 1, "fingerprint": 1, "images.XLarge": 1, "clickUrl": 1})
entries = db[products_collection].find(
{
"AnnoyIndex": {
"$in": annoy_list
},
'categories': category
},
{
"id": 1,
"fingerprint": 1,
"images.XLarge": 1,
"clickUrl": 1
},
).hint([('AnnoyIndex', 1)])
farthest_nearest = 1
nearest_n = []
# tt = 0
i = 0
# for i, entry in enumerate(entries):
for entry in entries:
i += 1
# t1 = time()
# tt += t1-t2
ent = entry['fingerprint']
d = NNSearch.distance(category, fp, ent, products_collection)
if not d:
# t2 = time()
# tdif = t2 - t1
# tt += tdif
continue
if i < number_of_matches:
nearest_n.append((entry, d))
farthest_nearest = 1
else:
if i == number_of_matches:
# sort by distance
nearest_n.sort(key=lambda tup: tup[1])
# last item in the list (index -1, go python!)
farthest_nearest = nearest_n[-1][1]
# Loop through remaining entries, if one of them is better, insert it in the correct location and remove last item
if d < farthest_nearest:
insert_at = number_of_matches - 2
while d < nearest_n[insert_at][1]:
insert_at -= 1
if insert_at == -1:
break
nearest_n.insert(insert_at + 1, (entry, d))
nearest_n.pop()
farthest_nearest = nearest_n[-1][1]
# t2 = time()
# tdif = t2-t1
# tt+=tdif
# print tt
# print "sorting entries took {0} secs".format(time()-start)
# t3 = time()
[result[0].pop('fingerprint') for result in nearest_n]
[result[0].pop('_id') for result in nearest_n]
nearest_n = [result[0] for result in nearest_n]
# t4 = time()
# print t4-t3
# return nearest_n
return time.time() - start
import os
from PIL import Image
import caffe
import numpy as np
from trendi import background_removal, Utils, constants
import cv2
import sys
import argparse
import glob
import time
import skimage
from PIL import Image
path = "/home/yonatan/test_set/female/Juljia_Vysotskij_0001.jpg"
image = Utils.get_cv2_img_array(path)
def cv2_image_to_caffe(image):
return skimage.img_as_float(cv2.cvtColor(image, cv2.COLOR_BGR2RGB)).astype(np.float32)
def find_face(image):
gray = cv2.cvtColor(image, constants.BGR2GRAYCONST)
face_cascades = [
cv2.CascadeClassifier(os.path.join(constants.classifiers_folder, 'haarcascade_frontalface_alt2.xml')),
cv2.CascadeClassifier(os.path.join(constants.classifiers_folder, 'haarcascade_frontalface_alt.xml')),
cv2.CascadeClassifier(os.path.join(constants.classifiers_folder, 'haarcascade_frontalface_alt_tree.xml')),
cv2.CascadeClassifier(os.path.join(constants.classifiers_folder, 'haarcascade_frontalface_default.xml'))]
cascade_ok = False
for cascade in face_cascades:
def deepfashion_to_db(
attribute_file='/data/jeremy/image_dbs/deep_fashion/category_and_attribute_prediction/list_attr_img.txt',
bbox_file='/data/jeremy/image_dbs/deep_fashion/category_and_attribute_prediction/list_bbox.txt',
bucket='https://tg-training.storage.googleapis.com/deep_fashion/category_and_attribute_prediction/',
# bucket = 'gs://tg-training/deep_fashion/',
use_visual_output=True):
'''
takes deepfashion lists of bbs and attrs, and images in bucket.
puts bb, attr, and link to file on bucket into db
:param attribute_file:
:param bbox_file:
:param bucket:
:param use_visual_output:
:return:
'''
with open(attribute_file, 'r') as fp:
attrlines = fp.readlines()
attrlines = attrlines[
2:] #1st line is # of files, 2nd line describes fields
fp.close()
with open(bbox_file, 'r') as fp2:
bboxlines = fp2.readlines()
bboxlines = bboxlines[
2:] #1st line is # of files, 2nd line describes fields
fp2.close()
bbox_files = [bboxline.split()[0] for bboxline in bboxlines]
# hydra_cats_for_deepfashion_folders = create_nn_imagelsts.deepfashion_to_tg_hydra(folderpath='/data/jeremy/image_dbs/deep_fashion/category_and_attribute_prediction/img')
with open('/data/jeremy/image_dbs/labels/deepfashion_to_hydra_map.txt',
'r') as fpx:
hydra_cats_for_deepfashion_folders = json.load(fpx)
fpx.close()
hydra_cats_dirsonly = [
dummy[0] for dummy in hydra_cats_for_deepfashion_folders
]
# print(hydra_cats_for_deepfashion_folders[0])
# print(hydra_cats_dirsonly[0])
# print(attrlines[0])
# print(bboxlines[0])
db = constants.db
# cursor = db.training_images.find()
for line in attrlines:
bbox = None
hydra_cat = None
info_dict = {}
info_dict['items'] = []
#raw_input('ret to cont')
attribute_list = []
#print line
path = line.split()[0]
vals = [int(i) + 1 for i in line.split()[1:]
] #the vals are -1, 1 so add 1 to get 0, 2
non_zero_idx = np.nonzero(vals)
print('nonzero idx:' + str(non_zero_idx))
for i in range(len(non_zero_idx[0])):
#print yonatan_constants.attribute_type_dict[str(non_zero_idx[0][i])]
attribute_list.append(yonatan_constants.attribute_type_dict[str(
non_zero_idx[0][i])])
print('attributes:' + str(attribute_list))
url = bucket + path
info_dict['items'].append({'attributes': attribute_list})
print('url:' + str(url))
try:
bbox_index = bbox_files.index(
path
) #there is prob a better way to search here than building another list
bbox = [int(x) for x in bboxlines[bbox_index].split()[1:]]
print('bbox ' + str(bbox) + ' line ' + str(bboxlines[bbox_index]))
#deepfashion bbox is x1 x2 y1 y2, convert to x y w h
bbox_tg = [bbox[0], bbox[1], bbox[2] - bbox[0], bbox[3] - bbox[1]]
info_dict['items'][0]['bb'] = bbox_tg
except ValueError:
print(path + ' is not in bboxfile list')
try:
folder_only = path.replace(
'img/', ''
) #the paths from attr_file (and bbfile) have img/folder not just folder
folder_only = os.path.dirname(folder_only)
hydra_category_index = hydra_cats_dirsonly.index(folder_only)
hydra_cat = hydra_cats_for_deepfashion_folders[
hydra_category_index][1]
print(
'hydracat ' + str(hydra_cat) + ' line ' +
str(hydra_cats_for_deepfashion_folders[hydra_category_index]))
info_dict['items'][0]['category'] = hydra_cat
except ValueError:
print(folder_only + ' is not in hydracat list')
img_arr = Utils.get_cv2_img_array(url)
if img_arr is None:
print('WARNING could not get ' + url)
else:
h, w = img_arr.shape[0:2]
if use_visual_output:
if bbox is not None:
cv2.rectangle(
img_arr, (bbox_tg[0], bbox_tg[1]),
(bbox_tg[0] + bbox_tg[2], bbox_tg[1] + bbox_tg[3]),
color=[255, 0, 0],
thickness=5)
cv2.imshow('deepfashion', img_arr)
cv2.waitKey()
info_dict['image_width'] = w
info_dict['image_height'] = h
info_dict['url'] = url
# info_dict['items'] = items
print('db entry:' + str(info_dict))
ack = db.training_images_deepfashion.insert_one(info_dict)
print('ack:' + str(ack.acknowledged))
def get_single_label_output(url_or_np_array,
net,
required_image_size=(224, 224),
resize=(250, 250),
analog_output=True,
from_binary_net=True):
'''
gets the output of a single-label classifier.
:param url_or_np_array:
:param net:
:param required_image_size: the size of the image the net wants (has been trained on), (WxH)
:param resize: resize img to this dimension. if this is > required_image_size then take center crop. pls dont make this < required_image_size
:param analog_output: get the actual class activations not just the max
:param binary_net: get the 2nd neuron output if this is a binary net (forget abt the first one since the neurons would be 'not item/item'
:return:
'''
#the below could be replaced by a call to
if isinstance(url_or_np_array, basestring):
image = url_to_image(url_or_np_array)
elif type(url_or_np_array) == np.ndarray:
image = url_or_np_array
image = Utils.get_cv2_img_array(url_or_np_array)
if image is None:
print('ug didnt manage to get an image...' + str(url_or_np_array))
return
print('multilabel working on image of shape:' + str(image.shape))
# save image to make sure no rgb/bgr funny business
# hash = hashlib.sha1()
# hash.update(str(time.time()))
# print hash.hexdigest()
# name=hash.hexdigest()[:10]+'.jpg'
# print('saving '+name)
# cv2.imwrite(name,image)
# load image, switch to BGR, subtract mean, and make dims C x H x W for Caffe
# im = Image.open(imagename)
# im = im.resize(required_imagesize,Image.ANTIALIAS)
# in_ = in_.astype(float)
if resize:
image = imutils.resize_keep_aspect(image,
output_size=resize,
output_file=None)
#print('original resized to '+str(image.shape))
height, width, channels = image.shape
crop_dx = width - required_image_size[0]
crop_dy = height - required_image_size[1]
if crop_dx != 0:
remove_x_left = crop_dx / 2
remove_x_right = crop_dx - remove_x_left
image = image[:,
remove_x_left:width - remove_x_right, :] #crop center x
#print('removing {} from left and {} from right leaving {}'.format(remove_x_left,remove_x_right,image.shape))
if crop_dy != 0:
remove_y_top = crop_dy / 2
remove_y_bottom = crop_dy - remove_y_top
image = image[remove_y_top:width -
remove_y_bottom, :, :] #crop center y
#print('removing {} from top and {} from bottom leaving {}'.format(remove_x_left,remove_x_right,image.shape))
image = np.array(image, dtype=np.float32) #.astype(float)
if len(image.shape) != 3: #h x w x channels, will be 2 if only h x w
print('got 1-chan image, turning into 3 channel')
#DEBUG THIS , ORDER MAY BE WRONG [what order? what was i thinking???]
image = np.array([image, image, image])
elif image.shape[
2] != 3: #for rgb/bgr, some imgages have 4 chan for alpha i guess
print('got n-chan image, skipping - shape:' + str(image.shape))
return
# image = image[:,:,::-1] for doing RGB -> BGR : since this is loaded nby cv2 its unecessary
# cv2.imshow('test',image)
image -= np.array((104.0, 116.0, 122.0))
image = image.transpose((2, 0, 1))
# shape for input (data blob is N x C x H x W), set data
net.blobs['data'].reshape(1, *image.shape)
net.blobs['data'].data[...] = image
# run net and take argmax for prediction
net.forward()
# out = net.blobs['score'].data[0].argmax(axis=0) #for a parse with per-pixel max
out = net.blobs['prob'].data[
0] #for the nth class layer #siggy is after sigmoid
the_chosen_one = out.argmax()
min = np.min(out)
max = np.max(out)
print('net output: {} answer:class {}'.format(out, the_chosen_one))
if analog_output:
if from_binary_net:
second_neuron_output = out[1]
print('binary output:' + str(out[1]))
return second_neuron_output
return out
return the_chosen_one
def pd_test_iou_and_cats(
images_file='/home/jeremy/image_dbs/pixlevel/pixlevel_fullsize_test_labels_v3.txt',
n_channels=len(constants.pixlevel_categories_v3),
output_labels=constants.pixlevel_categories_v3,
pd_to_output_converter=constants.
fashionista_augmented_zero_based_to_pixlevel_v3):
'''
:param images_file: file w lines of imgfile,labelfile. fash.augmented.zerobased list at 'pixlevel_fullsize_test_labels_faz.txt'
:param n_channels: number of categories
:param output_labels: what labels for output (used in legends)
:param pd_to_output_converter: convert pd to outputlabels using this mapping
:return: results from histogram - iou etc
'''
if not (os.path.exists(images_file)):
logging.warning('file {} does not exist, exiting'.format(images_file))
return
with open(images_file, 'r') as fp:
lines = fp.readlines()
if len(lines) == 0:
logging.warning(
'got no lines from {}, exiting'.format(images_file))
return
print('{} has lines like:\n{}'.format(images_file, lines[0]))
imgfiles = [l.split()[0] for l in lines]
labelfiles = [l.split()[1] for l in lines]
hist = np.zeros((n_channels, n_channels))
for image_file, labelfile in zip(imgfiles, labelfiles):
image_arr = Utils.get_cv2_img_array(image_file)
gt_arr = cv2.imread(labelfile)
print('gt size {} img size {} for {} and {}'.format(
gt_arr.shape, image_arr.shape, labelfile, image_file))
result = get_pd_results(img_arr=image_arr)
if result is not None:
mask, labels, pose = result[:]
else:
logging.warning(
'got None result from get_pd_results in pd_test_iou_and_cats')
continue
# mask, labels, pose = paperdoll_parse_enqueue.paperdoll_enqueue(image_arr, async=False)
conversion_utils.count_values(mask)
converted_mask = convert_results(
mask, labels, pd_to_nd_label_converter=pd_to_output_converter)
conversion_utils.count_values(converted_mask)
print('mask uniques {} converted uniques {} gt uniques {}'.format(
np.unique(mask), np.unique(converted_mask), np.unique(gt_arr)))
final_mask = pipeline.after_pd_conclusions(mask, labels)
print('mask, after conclusions')
conversion_utils.count_values(final_mask)
converted_final_mask = convert_results(
final_mask,
labels,
pd_to_nd_label_converter=pd_to_output_converter)
conversion_utils.count_values(converted_final_mask)
print('final mask uniques {} gt uniques {}'.format(
np.unique(converted_final_mask), np.unique(gt_arr)))
#before conclusions
savename = os.path.basename(image_file).replace('.jpg', '_legend.jpg')
imutils.show_mask_with_labels(converted_mask,
labels=output_labels,
original_image=image_file,
visual_output=False,
savename=savename,
save_images=True)
#after conclusions
savename_finalmask = os.path.basename(image_file).replace(
'.jpg', '_afterpdconclusions_legend.jpg')
imutils.show_mask_with_labels(converted_final_mask,
labels=output_labels,
original_image=image_file,
visual_output=False,
savename=savename_finalmask,
save_images=True)
#ground truth
gtsavename = os.path.basename(image_file).replace(
'.jpg', '_gt_legend.jpg')
imutils.show_mask_with_labels(gt_arr,
labels=output_labels,
original_image=image_file,
visual_output=False,
savename=gtsavename,
save_images=True)
#mask (after conclusions)
bmpname = os.path.basename(image_file).replace('.jpg', 'pd.bmp')
cv2.imwrite(bmpname, converted_final_mask)
print('saving naive legend to ' + savename +
' afterconclusions legend to ' + savename_finalmask +
' gt legend to ' + gtsavename + ', mask to ' + bmpname)
hist += jrinfer.fast_hist(gt_arr, converted_final_mask, n_channels)
results = jrinfer.results_from_hist(hist, labels=labels)
return results
def fashionista_to_ultimate_21(img_arr_or_url_or_file):
##########warning not finished #################3
#also this is for images saved using the fashionista_categories_augmented labels, raw d output is with a dictionary of arbitrary labels
#so use get_pd_results_on_db_for_webtool.convert_and_save_results
#actually this is a better place for that so now its copied here
ultimate_21 = [
'bgnd', 'bag', 'belt', 'blazer', 'coat', 'dress', 'eyewear', 'face',
'hair', 'hat', 'jeans', 'legging', 'pants', 'shoe', 'shorts', 'skin',
'skirt', 'stocking', 'suit', 'sweater', 'top'
]
#tossed,'bodysuit', 'socks','bra'
#tossed, 'accessories', 'ring', 'necklace', 'bracelet', 'wallet', 'tie', 'earrings', 'gloves', 'watch']
#scarf aded to shirt since it mostly shows up there
# ## fashionista classes:
fashionista_categories_augmented = [
'', 'null', 'tights', 'shorts', 'blazer', 't-shirt', 'bag', 'shoes',
'coat', 'skirt', 'purse', 'boots', 'blouse', 'jacket', 'bra', 'dress',
'pants', 'sweater', 'shirt', 'jeans', 'leggings', 'scarf', 'hat',
'top', 'cardigan', 'accessories', 'vest', 'sunglasses', 'belt',
'socks', 'glasses', 'intimate', 'stockings', 'necklace', 'cape',
'jumper', 'sweatshirt', 'suit', 'bracelet', 'heels', 'wedges', 'ring',
'flats', 'tie', 'romper', 'sandals', 'earrings', 'gloves', 'sneakers',
'clogs', 'watch', 'pumps', 'wallet', 'bodysuit', 'loafers', 'hair',
'skin', 'face'
] #0='',1='null'(bgnd) 57='face'
#CONVERSION FROM FASH 57 TO ULTIMATE21
conversion_dictionary_strings = {
'bgnd': ['null'],
'bag': ['bag', 'purse'],
'belt': ['belt'],
'blazer': ['blazer', 'jacket', 'vest'],
'top': ['t-shirt', 'shirt', 'blouse', 'top', 'sweatshirt', 'scarf'],
'coat': ['coat', 'cape'],
'dress': ['dress', 'romper'],
'suit': ['suit'],
'face': ['face'],
'hair': ['hair'],
'hat': ['hat'],
'jeans': ['jeans'],
'legging': ['tights', 'leggings'],
'pants': ['pants'],
'shoe': [
'shoes', 'boots', 'heels', 'wedges', 'pumps', 'loafers', 'flats',
'sandals', 'sneakers', 'clogs'
],
'shorts': ['shorts'],
'skin': ['skin'],
'skirt': ['skirt'],
'stocking': ['intimate', 'stockings'],
'eyewear': ['sunglasses', 'glasses'],
'sweater': ['sweater', 'cardigan', 'jumper']
}
index_conversion = [
-666 for i in range(len(fashionista_categories_augmented))
]
for k, v in conversion_dictionary_strings.iteritems():
ultimate_21_index = ultimate_21.index(k)
for fash_cat in v: #no need to check if the fashcat is in v since all the values here are in fashionista....
fash_index = fashionista_categories_augmented.index(fash_cat)
# fash_index = constants.fashionista_categories_augmented_zero_based.index(fash_cat)
logging.debug(
'ultimate index {} cat {} fash index {} cat {}'.format(
ultimate_21_index, ultimate_21[ultimate_21_index],
fash_index, fashionista_categories_augmented[fash_index]))
index_conversion[fash_index] = ultimate_21_index
print(index_conversion)
# for i in range(len(index_conversion)):
# if index_conversion[i] == -666:
# print('unmapped fashcat:'+str(i)+fashionista_categories_augmented[i])
if isinstance(img_arr_or_url_or_file, basestring):
mask = Utils.get_cv2_img_array(img_arr_or_url_or_file)
#todo - check why get_cv2_img_array doesnt like getting a mask
else:
mask = img_arr_or_url_or_file
# mask=cv2.imread(file,cv2.IMREAD_GRAYSCALE)
if mask is None:
if isinstance(img_arr_or_url_or_file, basestring):
logging.warning('could not get filename/url:' +
str(img_arr_or_url_or_file))
else:
logging.warning('could not get file/url')
return None
if len(mask.shape) == 3:
logging.warning('multichannel mask, taking chan 0')
mask = mask[:, :, 0]
uniques = np.unique(mask)
# print('uniques:'+str(uniques))
for u in uniques:
newval = index_conversion[u] #find indice(s) of vals matching unique
if newval < 0: #if you want to 'throw away' a cat just map it to background, otherwise
newval = 0
print('replacing index {} with newindex {}'.format(u, newval))
mask[mask == u] = newval
return mask
def detect_with_scale_pyramid_and_sliding_window(image_filename_or_cv2_array,
prototxt,
caffemodel,
mean_B=128,
mean_G=128,
mean_R=128,
image_width=150,
image_height=200,
show_visual_output=False):
caffe.set_mode_gpu()
if host == 'jr-ThinkPad-X1-Carbon':
caffe.set_mode_cpu()
net = caffe.Net(prototxt, caffemodel, caffe.TEST)
img_arr = Utils.get_cv2_img_array(image_filename_or_cv2_array)
orig_img_arr = img_arr.copy()
if (0):
if mean_B is not None and mean_G is not None and mean_R is not None:
img_arr[:, :, 0] = img_arr[:, :, 0] - mean_B
img_arr[:, :, 1] = img_arr[:, :, 1] - mean_G
img_arr[:, :, 2] = img_arr[:, :, 2] - mean_R
img_arr = np.divide(img_arr, 255.0)
transformed_image = img_arr.transpose((2, 0, 1))
net.blobs['data'].data[...] = transformed_image
### perform classification
output = net.forward()
logging.debug('orig shape ' + str(img_arr.shape))
h, w = img_arr.shape[0:2]
# if h != image_height or w != image_width:
# img_arr = cv2.resize(img_arr,(image_width,image_height))
# copy the image data into the memory allocated for the net
i = 0
# loop over the image pyramid
for resized in pyramid(img_arr, scale=1.5):
# loop over the sliding window for each layer of the pyramid
for (x, y, window) in sliding_window(resized,
stepSize=32,
windowSize=(image_width,
image_height)):
# if the window does not meet our desired window size, ignore it
if window.shape[0] != image_height or window.shape[
1] != image_width:
logging.debug('got bad window shape from sliding_window')
continue
# THIS IS WHERE YOU WOULD PROCESS YOUR WINDOW, SUCH AS APPLYING A
# MACHINE LEARNING CLASSIFIER TO CLASSIFY THE CONTENTS OF THE
# WINDOW
img_arr2 = window.copy()
if mean_B is not None and mean_G is not None and mean_R is not None:
img_arr2[:, :, 0] = img_arr2[:, :, 0] - mean_B
img_arr2[:, :, 1] = img_arr2[:, :, 1] - mean_G
img_arr2[:, :, 2] = img_arr2[:, :, 2] - mean_R
img_arr2 = np.divide(img_arr2, 255.0)
transformed_image = img_arr2.transpose((2, 0, 1))
net.blobs['data'].data[...] = transformed_image
### perform classification
output = net.forward()
n = net.blobs
print('net ' + str(n))
output = n['output_layer'].data
print('output ' + str(output))
# since we do not have a classifier, we'll just draw the window
clone = resized.copy()
cv2.rectangle(clone, (x, y), (x + image_width, y + image_height),
(0, 255, 0), 2)
if show_visual_output:
cv2.imshow("sliding window", clone)
cv2.imshow("window", window)
cv2.waitKey(1)
time.sleep(0.025)
fname = 'output' + str(i) + '.jpg'
# cv2.imwrite(fname,clone)
i = i + 1
