"""

bgrImg = cv2.imread(imgPath)

if bgrImg is None:

raise Exception("Unable to load image: {}".format(imgPath))

rgbImg = cv2.cvtColor(bgrImg, cv2.COLOR_BGR2RGB)

# assert np.isclose(norm(rgbImg), 11.1355)

dets = dlibAlign.getAllFaceBoundingBoxes(rgbImg)

# dets的元素个数即为脸的个数

print("Number of faces detected: {}".format(len(dets)))

face_path = {} # 存放多个脸部图片及prewhitened

blury_arr = {}

# 使用enumerate 函数遍历序列中的元素以及它们的下标

# 下标i即为人脸序号

for i, bb in enumerate(dets):

if bb is not None:

alignedFace = dlibAlign.align(160, rgbImg, bb) # 缩放裁剪对齐

gray_face = cv2.cvtColor(alignedFace, cv2.COLOR_BGR2GRAY)

blury_value = cv2.Laplacian(gray_face, cv2.CV_64F).var()

if blury_value < BLURY_THREHOLD:

print('A blur face (%d) captured, avoid it.' % blury_value)

#continue

else:

print('Blur Value: %d, good' % blury_value)

prewhitened = facenet.prewhiten(alignedFace)

tmp_image_path = imgPath.rsplit('.', 1)[0] + str(i) + '.' + imgPath.rsplit('.', 1)[1]

misc.imsave(tmp_image_path, alignedFace) # 保存为图像

face_path[tmp_image_path] = prewhitened

blury_arr[tmp_image_path] = blury_value

dist_12 = math.hypot(c_1[0] - c_2[0], c_1[1] - c_2[1])

dist_23 = math.hypot(c_2[0] - c_3[0], c_2[1] - c_3[1])

dist_13 = math.hypot(c_1[0] - c_3[0], c_1[1] - c_3[1])

my_list = [dist_12, dist_23, dist_13]

my_list.sort()

if math.pow(my_list[0], 2) + math.pow(my_list[1], 2) - math.pow(my_list[2], 2) > 0:

return True

else:

img = misc.imread(os.path.expanduser(image_path))

img_size = np.asarray(img.shape)[0:2]

with graph2.as_default():

with sess2.as_default():

bounding_boxes, bounding_points = align.detect_face.detect_face(img, minsize, pnet, rnet, onet, threshold, factor)

nrof_faces = bounding_boxes.shape[0] # 人脸数目

width = img_size[1]

height = img_size[0]

if nrof_faces > 0:

face_path = {} # 存放多个脸部图片

blury_arr = {}

imgs_style = {} # 存放不同人脸图对应的类型，如左侧、右侧、低头、抬头、低像素、过模糊、标准

face_body = {} # 人脸对应的人体图片路径

#print('The number of faces detected: {}'.format(nrof_faces))

for i in range(nrof_faces): # 遍历所有faces

style = []

det = np.squeeze(bounding_boxes.copy()[i, 0:4])

# det = np.squeeze(align.detect_face.rerec(bounding_boxes.copy())[i, 0:4])

bounding_point = bounding_points[:, i] # 按i获取多个人脸的point

bb = np.zeros(4, dtype=np.int32) # 坐标

bb[0] = np.maximum(det[0] - margin / 2, 0)

bb[1] = np.maximum(det[1] - margin / 2, 0)

bb[2] = np.minimum(det[2] + margin / 2, img_size[1])

bb[3] = np.minimum(det[3] + margin / 2, img_size[0])

if bb[0] == 0 or bb[1] == 0 or bb[2] >= width or bb[3] >= height:

print('Out of boundary ({},{},{},{})'.format(bb[0],bb[1],bb[2],bb[3]))

continue

else:

eye_1 = [bounding_point[0], bounding_point[5]]

eye_2 = [bounding_point[1], bounding_point[6]]

nose = [bounding_point[2], bounding_point[7]]

mouth_1 = [bounding_point[3], bounding_point[8]]

mouth_2 = [bounding_point[4], bounding_point[9]]

face_width = bb[2] - bb[0]

face_height = bb[3] - bb[1]

if face_width * face_height < minsize * minsize:

print("to small to recognise ({},{})".format(face_width,face_height))

continue

else:

middle_point = (bb[2] + bb[0])/2

y_middle_point = (bb[3] + bb[1]) / 2

print('eye_1[0]={}, eye_2[0]={}, middle_point={}, bounding_point[5]={}, bounding_point[6]={}, y_middle_point={}'.format(eye_1[0], eye_2[0], middle_point, bounding_point[5], bounding_point[6], y_middle_point))

if eye_1[0] > middle_point:

print('(Left Eye on the Right) Add style')

style.append('left_side')

# continue

elif eye_2[0] < middle_point:

print('(Right Eye on the left) Add style')

style.append('right_side')

# continue

elif max(bounding_point[5], bounding_point[6]) > y_middle_point:

print('(Eye lower than middle of face) Skip')

style.append('lower_head')

# continue

# 左右两个眼睛最低的y轴，低于图片的中间高度，就认为是低头

# style.append('lower_head')

#elif bounding_point[7] < y_middle_point:

# 鼻子的y轴高于图片的中间高度，就认为是抬头

# style.append('raise_head')

else:

style.append('front')

#print('Good Face')

if SAVE_FULL_BODY is True:

file_path_to_save = image_path.rsplit('.', 1)[0] + '_' + str(i) + '_t1.' + 'jpg'

result, width_ratio, height_ratio = save_body_by_face_position_jpg(bb,img,file_path_to_save)

cropped = img[bb[1]:bb[3], bb[0]:bb[2], :] # 裁剪

aligned = misc.imresize(cropped, (160, 160), interp='cubic') # 缩放图像

# Need to detect if face is too blury to be detected

gray_face = cv2.cvtColor(aligned, cv2.COLOR_BGR2GRAY)

blury_value = cv2.Laplacian(gray_face, cv2.CV_64F).var()

if blury_value < BLURY_THREHOLD:

print('A blur face (%d) captured, avoid it.' %blury_value)

style = ['blury']

#isDirty = True

# continue

else:

print('Blur Value: %d, good'%blury_value)

new_image_path = image_path.rsplit('.', 1)[0] + '_' + str(i) + '.' + EXT_IMG #image_path.rsplit('.', 1)[1]

misc.imsave(new_image_path, aligned) # 保存为图像

prewhitened = facenet.prewhiten(aligned)

face_path[new_image_path] = prewhitened

blury_arr[new_image_path] = blury_value

imgs_style[new_image_path] = '|'.join(style) # 如 'left_side|raise_head'

if SAVE_FULL_BODY and result:

face_body[new_image_path] = file_path_to_save

else:

face_body[new_image_path] = ''

#isDirty_arr[new_image_path] = isDirty

#print(prewhitened.shape)

return face_path, imgs_style, blury_arr, face_body #, isDirty_arr , dlib_bb_dict

img = misc.imread(os.path.expanduser(imgpath))

prewhitened = facenet.prewhiten(img)

with graph.as_default():

with sess.as_default():

embedding = FaceProcessing.FaceProcessingImageData(prewhitened, sess, graph)[0]

min_area = 200

img_gray = cv2.imread(os.path.expanduser(img_path), 0)

if uuid in preFrameOnDevice:

frameDelta = cv2.absdiff(preFrameOnDevice[uuid], img_gray)

preFrameOnDevice[uuid] = img_gray

thresh = cv2.threshold(frameDelta, 25, 255, cv2.THRESH_BINARY)[1]

(cnts, _) = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)

delta_value = 0

for c in cnts:

# if the contour is too small, ignore it

delta_value+= cv2.contourArea(c)

if delta_value >= min_area:

#(x, y, w, h) = cv2.boundingRect(c)

print(cv2.boundingRect(c))

#cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 255, 0), 2)

print('Moved delta %d'% delta_value)

return True

return False

else:

preFrameOnDevice[uuid] = img_gray

p_ids,waiting):

if len(url) < 1 or len(uuid) < 1 or len(objid) < 1 or len(img_type) < 1:

return

print(sqlId)

if (img_type == 'object'):

if not DO_NOT_REPORT_TO_SERVER:

save2gst(uuid, objid, url, '', 'object', accuracy, int(fuzziness), 0, "", img_ts,tid,waiting) # 发送请求给workai

return

# 换成迁移训练，不需要预生成这个数据

# with app.app_context():

# man = People.query.filter_by(id=ownerid).first()

# man.aliyun_url = url

# db.session.add(man)

# db.session.commit()

#

# train = TrainSet(url=url,

# embed=embedding,

# device_id=uuid,

# face_id=ownerid) # 系统自动label，生成一个训练数据

# db.session.add(train)

# db.session.commit()

if not DO_NOT_REPORT_TO_SERVER:

dist = np.sqrt(np.sum(np.square(np.subtract(emb1, emb2))))

# d = emb1 - emb2

# sqL2 = np.dot(d, d)

# print("+ Squared l2 distance between representations: {:0.3f}, dist is {:0.3f}".format(sqL2,dist))

# print("+ distance between representations: {:0.3f}".format(dist))

# return sqL2

"""

return '.' in filename and \

c = int(confident*100)

v = int(val*100)

if v == c :

return 0.10

if v > c :

return 0.01

percent = (float(c) - float(v))/float(c)

if (percent<0.10):

percent = 0.49

else:

percent = percent + 0.50

if (percent>=1.0):

percent = 0.99

percent = round(percent, 2)

img = None

if img_path is None and img_buff is None:

return 1

if img_buff is None:

img = misc.imread(os.path.expanduser(img_path))

else:

img = img_buff

gray_face = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

blury_value = cv2.Laplacian(gray_face, cv2.CV_64F).var()

print(">>> object blury_value: %d" %(blury_value))

total = 0

found = 0

people = None

#遍历整个数据库, 检查这个人是谁

if SVM_TRAIN_WITHOUT_CATEGORY is True:

people = People.query.filter_by(group_id=current_groupid, classId=classid).all()

else:

people = People.query.filter_by(group_id=current_groupid, style=style, classId=classid).all()

if people:

for person in people:

val = compare(embedding, person.embed)

total = total+1

face_accuracy = check_accuracy(confident_value, val) # facenet计算的accuracy

if face_accuracy >= CONFIDENT_VALUE_THRESHOLD:

found = found+1

if total >= 500:

break

total = 0

found = 0

people = None

#遍历整个数据库, 检查这个人是谁

if SVM_TRAIN_WITHOUT_CATEGORY is True:

people = People.query.filter_by(group_id=current_groupid, classId=classid).all()

else:

people = People.query.filter_by(group_id=current_groupid, style=style, classId=classid).all()

if people:

for person in people:

val = compare2(embedding, person.embed)

total = total+1

#face_accuracy = check_accuracy(confident_value, val) # facenet计算的accuracy

face_accuracy = val

print('face_accuracy={}'.format(face_accuracy))

#if face_accuracy >= 0.55:

if face_accuracy >= 0.70:

found = found+1

if total >= 500:

break

if EN_SOFTMAX is True and SOFTMAX_ONLY is True:

return None, None, None

result_classId = {'Id': None, 'dist': None}

#遍历整个数据库，检查这张图片不是人脸

people = People.query.filter_by(group_id=current_groupid, classId="notface").all()

if people:

min_value = min([(compare(embedding, p.embed), p.objId, p.classId, p.id) for p in people]) # 遍历数据库并求最小compare值

if min_value[0] < confident_value:

face_accuracy = check_accuracy(confident_value, min_value[0]) # facenet计算的accuracy

if face_accuracy > 0.9:

print("this must be a None-face image")

return min_value[2], min_value[3], face_accuracy

#遍历整个数据库, 检查这个人是谁

people = People.query.filter_by(group_id=current_groupid, style=style).all()

if people:

min_value = min([(compare(embedding, p.embed), p.objId, p.classId, p.id) for p in people if p.classId != "notface"]) # 遍历数据库并求最小compare值

print(min_value)

face_accuracy = check_accuracy(confident_value, min_value[0]) # facenet计算的accuracy

if face_accuracy >= CONFIDENT_VALUE_THRESHOLD:

result_classId['Id'] = min_value[2]

result_classId['dist'] = min_value[0]

face_accuracy = check_accuracy(confident_value, min_value[0]) # facenet计算的accuracy

print(">>> same people(db): accuracy=%f" % (face_accuracy))

return result_classId['Id'], min_value[3], face_accuracy

if notFace is True:

classId = "notface"

else:

classId = objid

if not os.path.exists(filepath):

print("file not exists %s" %(filepath))

return

embedding = featureCalculation(filepath)

with app.app_context():

people = People(embed=embedding, uuid=uuid, group_id=group_id,

objId=objid, aliyun_url=url, classId=classId, style=style)

db.session.add(people)

db.session.commit()

os.remove(filepath)

def __init__(self, dbpath, isSave=False):

print("MyDB: __init__")

self.isSave = isSave

self.collection = {}

if (os.path.isfile(dbpath)):

with open(dbpath) as fJson:

self.collection = json.load(fJson)

self.dbpath = dbpath

def fetch(self):

return self.collection.copy()

def find(self, key, fields):

return self.collection.get(key, fields)

'''

def insert(self, key, fields):

self.collection[key] = fields

if self.isSave is True:

self.save()

def update(self, key, fields):

self.collection.update({key:fields})

if self.isSave is True:

self.save()

def remove(self, key):

self.collection.pop(key, "Key not Found!")

if self.isSave is True:

self.save()

def batch_insert(self, items):

print("items={}".format(items))

for key, value in items.items():

if isinstance(value,dict):

self.insert(key, value)

else:

print("batch_insert: invalid data format.")

if self.isSave is True:

self.save()

def save(self):

if self.dbpath is None:

return

with open(self.dbpath, 'w') as fJson:

global AutogroupDB

global AutogroupDatasetDB

global isSyncAutogroupDataset

global isStartAutogroup

print("disposeAutoGroupFunc: type={}, json={}".format(type, json))

if AutogroupDB is None:

AutogroupDB = MyDB(AUTOGROUP_UNKNOWNFACES_DB)

if AutogroupDatasetDB is None:

AutogroupDatasetDB = MyDB(AUTOGROUP_DATASET_DB)

if type == "dataset":

AutogroupDatasetDB.batch_insert(json)

print("Download autogroup dataset...")

elif type == "syncdataset":

isSyncAutogroupDataset = True

print("Set isSyncAutogroupDataset to True")

elif type == "autogroup":

if json is not None:

AutogroupDB.batch_insert(json)

isStartAutogroup = True

failedDownloadedItems = []

for person in result:

faceId = person.get("faceId")

urls = person.get("urls")

print('--> {}'.format(faceId))

for url in urls:

#print(' {}'.format(url))

# url,faceid 从点圈群相册获取

# todo 可以用for循环解析群相册获取的json数据

img_url = url['url']

faceid = faceId

style = url['style']

if style != 'front':

#print("style=%s"%style);

continue

#status, embedding = down_img_embedding(img_url, group_id, faceid, style=style)

img_path = save_embedding.get_image_path_dst(img_url, group_id, faceId, style, "autogroup")

#print("img_path = {}".format(img_path))

embedding_path = save_embedding.get_embedding_path(img_path)

embedding = None

if not os.path.exists(img_path):

img_path = save_embedding.download_img_for_svm_dst(img_url, group_id, faceId, style, "autogroup")

if img_path:

if not os.path.exists(embedding_path):

img = misc.imread(os.path.expanduser(img_path)) # 手动裁剪后的图片需要再缩放一下

aligned = misc.imresize(img, (image_size, image_size))

misc.imsave(img_path, aligned)

embedding = featureCalculation(img_path)

embedding_path = save_embedding.get_embedding_path(img_path)

save_embedding.create_embedding_string(embedding, embedding_path)

#print("1, type(embedding)={}".format(type(embedding)))

old_autogroup_set = AutoGroupSet.query.filter_by(url=img_url, group_id=group_id, is_or_isnot=True, style=style).first()

if not old_autogroup_set:

if embedding is None:

embedding_path = save_embedding.get_embedding_path(img_path)

embedding = save_embedding.read_embedding_string(embedding_path)

embedding = np.asarray(embedding)

print("read_embedding_string...........")

print("2, type(embedding)={}".format(type(embedding)))

unique_face_id = ''

if unique_face_id in url:

unique_face_id = url['unique_face_id']

#unique_face_id = url['unique_face_id'] if unique_face_id in url else ''

autoGroupSet = AutoGroupSet(url=img_url, group_id=group_id, is_or_isnot=True,

device_id='', face_id=faceId, unique_face_id=unique_face_id, style=style, filepath=img_path, embed=embedding)

db.session.add(autoGroupSet)

db.session.commit()

print('-> syncAutogroupDataset downloaded url {} to {}'.format(url['url'], img_path))

else:

failedDownloadedItems.append(person)

group_id = get_current_groupid()

#host="http://localhost:3000/restapi/datasync/token/" + str(group_id)

host = "http://workaihost.tiegushi.com/restapi/datasync/token/" + str(group_id)

result = None

try:

response = urlopen(host, timeout=10)

except HTTPError as e:

print('HTTPError: ', e.code)

return False

except URLError as e:

print('URLError: ', e.reason)

return False

except Exception as e:

print('Error: ', e)

return False

else:

# everything is fine

if 200 == response.getcode():

result = response.readline()

#print(result)

result = json.loads(result)

failedDownloadedItems = downloadAutogroupDataset(result, group_id)

try_count = 0

while len(failedDownloadedItems) > 0:

try_count = try_count+1

print("len(failedDownloadedItems) = {}, try_count={}".format(len(failedDownloadedItems), try_count))

if try_count > 3:

print("We have tried 3 times to download the autogroup dataset.")

break

failedDownloadedItems = downloadAutogroupDataset(failedDownloadedItems, group_id)

#Remove invalid data from local DB

urlsInLocalDB = AutoGroupSet.query.filter_by(group_id=group_id, style="front").all()

urlsOnServer = dict()

for person in result:

faceId = person.get("faceId")

urls = person.get("urls")

for url in urls:

img_url = url['url']

faceid = faceId

style = url['style']

urlsOnServer[img_url] = group_id, faceId, style

print("len(urlsInLocalDB) = {}".format(len(urlsInLocalDB)))

print("len(urlsOnServer) = {}".format(len(urlsOnServer)))

#print("urlsOnServer = {}".format(urlsOnServer))

if urlsInLocalDB:

for item in urlsInLocalDB:

image_path = None

#print("item = {}, item.url={}".format(item, item.url))

if item.url not in urlsOnServer.keys():

print("{}, {}, {}, {} is not on server, delete it from local DB.".format(item.url, item.group_id, item.face_id, item.style))

if item.filepath:

image_path = item.filepath

db.session.delete(item)

db.session.commit()

if image_path and os.path.isfile(image_path):

print('Remove image from local {}'.format(image_path))

os.remove(image_path)

embedding_path = save_embedding.get_embedding_path(image_path)

if embedding_path and os.path.isfile(embedding_path):

print('Remove embedding from local {}:'.format(embedding_path))

os.remove(embedding_path)

#Remove invalid photos from local

'''

return True

else:

print('response code != 200')

print("autogroupThreadSubFunc: len(unknownImages_array)={}".format(len(unknownImages_array)))

current_order_list = OrderedDict()

for item in unknownImages_array:

current_order_list[item["url"]] = item["face_id"], item["filepath"]

start_time = time.time()

#unknown_length = len(unknownImages_array)

current_groupid = get_current_groupid()

device_id = get_deviceid()

people = AutoGroupSet.query.filter_by(group_id=current_groupid, style="front").all()

print("len(people)={}".format(len(people)))

if people:

for person in people:

#facial_encodings[getFacialImagePath(person.filepath)] = person.embed

#print("person.url={}, person.embed={}".format(person.url, person.embed))

#numpy.ndarray

facial_encodings[person.url] = person.face_id, person.embed

#print("type(person.embed)={}".format(type(person.embed)))

#print("person.embed={}".format(person.embed))

current_order_list[person.url] = person.face_id, person.filepath

print("current_order_list = {}".format(current_order_list))

#print("facial_encodings={}".format(facial_encodings))

print("autogroupThreadSubFunc get facial encodings costs {} S".format(time.time() - start_time))

#sendMessage2Group(device_id, toid, '-> Train cost {}s'.format(time.time() - start_time))

print("facial_encodings={}".format(facial_encodings))

results = clustering_people.cluster_unknown_people(facial_encodings, current_order_list)

json_string = "{}devId:{}, group_id:{}, results:{}{}".format('{', device_id, current_groupid, results, '}')

json_dict = {"devId":device_id, "group_id":current_groupid, "results":results}

global AutogroupDB

global AutogroupDatasetDB

global isSyncAutogroupDataset

global isStartAutogroup

unknown_faceId = "unknown"

while True:

try:

if isSyncAutogroupDataset is True:

if not syncAutogroupDatasetFunc():

time.sleep(6)

continue

isSyncAutogroupDataset = False

datasetDic = []

if AutogroupDatasetDB is not None:

datasetDic = AutogroupDatasetDB.fetch()

if (len(datasetDic) > 0):

print("len(AutogroupDatasetDB)={}".format(len(datasetDic)))

print("autogroupThreadFunc: download dataset %d" % len(datasetDic))

for key in datasetDic:

print("key = {}".format(key))

info = datasetDic[key]

#if SVM_TRAIN_WITHOUT_CATEGORY is True:

# info['style'] = 'front'

print("info = {}".format(info))

ret = urllib2.urlopen(info['url'])

if ret.code != 200:

AutogroupDatasetDB.remove(key)

print("URL{} not exists, continue.".format(info['url']))

print("info['url'] = {}".format(info['url']))

img_path = save_embedding.get_image_path_dst(info['url'], info['group_id'], info['face_id'], info['style'], "autogroup")

print("img_path = {}".format(img_path))

embedding_path = save_embedding.get_embedding_path(img_path)

embedding = None

if not os.path.exists(img_path):

img_path = save_embedding.download_img_for_svm_dst(info['url'], info['group_id'], info['face_id'], info['style'], "autogroup")

if img_path:

if not os.path.exists(embedding_path):

img = misc.imread(os.path.expanduser(img_path)) # 手动裁剪后的图片需要再缩放一下

aligned = misc.imresize(img, (image_size, image_size))

misc.imsave(img_path, aligned)

embedding = featureCalculation(img_path)

embedding_path = save_embedding.get_embedding_path(img_path)

save_embedding.create_embedding_string(embedding, embedding_path)

old_autogroup_set = AutoGroupSet.query.filter_by(url=info['url'], group_id=info['group_id'], is_or_isnot=True, style=info['style']).first()

if not old_autogroup_set:

if embedding is None:

embedding_path = save_embedding.get_embedding_path(img_path)

embedding = save_embedding.read_embedding_string(embedding_path)

embedding = np.asarray(embedding)

unique_face_id = info['unique_face_id'] if unique_face_id in info else ''

autoGroupSet = AutoGroupSet(url=info['url'], group_id=info['group_id'], is_or_isnot=True,

device_id=info['device_id'], face_id=info['face_id'], unique_face_id=unique_face_id, style=info['style'], filepath=img_path, embed=embedding)

db.session.add(autoGroupSet)

db.session.commit()

print('-> autogroupThreadFunc downloaded url {} to {}'.format(info['url'], img_path))

AutogroupDatasetDB.remove(key)

datasetDic = []

if AutogroupDB is not None:

datasetDic = AutogroupDB.fetch()

if isStartAutogroup is True:

facial_encodings = OrderedDict()

if (len(datasetDic) > 0):

print("len(AutogroupDB)={}".format(len(datasetDic)))

print("autogroupThreadFunc: download Autogroup data %d" % len(datasetDic))

unknownImages_array = []

for key in datasetDic:

info = datasetDic[key]

if 'url' not in info or 'group_id' not in info or 'face_id' not in info:

print("Missing key information in message.")

continue

ret = urllib2.urlopen(info['url'])

if ret.code != 200:

AutogroupDB.remove(key)

print("URL{} not exists, continue.".format(info['url']))

img_path = save_embedding.get_image_path_dst(info['url'], info['group_id'], unknown_faceId, info['style'], "autogroup")

embedding_path = save_embedding.get_embedding_path(img_path)

basepath = os.path.abspath(os.getenv('RUNTIME_BASEDIR',os.path.dirname(__file__)))

local_path = os.path.join(basepath, "face_testdataset/" + info['group_id']+"/noname/"+os.path.basename(info['url']))

print("local_path = {}".format(local_path))

if os.path.exists(local_path):

shutil.copy(local_path, img_path)

print("Copied local file {} to {}".format(local_path, img_path))

if not os.path.exists(img_path):

img_path = save_embedding.download_img_for_svm_dst(info['url'], info['group_id'], unknown_faceId, info['style'], "autogroup")

if img_path:

if not os.path.exists(embedding_path):

img = misc.imread(os.path.expanduser(img_path)) # 手动裁剪后的图片需要再缩放一下

aligned = misc.imresize(img, (image_size, image_size))

misc.imsave(img_path, aligned)

embedding = featureCalculation(img_path)

embedding_path = save_embedding.get_embedding_path(img_path)

save_embedding.create_embedding_string(embedding, embedding_path)

#AutoGroupEmbeddings.append({info['url']: embedding})

#facial_encodings[getFacialImagePath(img_path)] = embedding

else:

embedding_path = save_embedding.get_embedding_path(img_path)

embedding = save_embedding.read_embedding_string(embedding_path)

#list

facial_encodings[info['url']] = unknown_faceId, np.asarray(embedding)

print("type(embedding) = {}".format(type(embedding)))

unknownImages_array.append({"filepath":img_path, "url":info['url'], "face_id":unknown_faceId, "style":info['style']})

AutogroupDB.remove(key)

print("len(facial_encodings)={}".format(len(facial_encodings)))

if len(facial_encodings) > 0:

#TODO compare facial

autogroupThreadSubFunc(facial_encodings, unknownImages_array)

else:

autogroupThreadSubFunc(facial_encodings, [])

isStartAutogroup = False

except Exception as ex:

print('autogroupThreadFunc: except:', ex)

isSyncAutogroupDataset = False

isStartAutogroup = False

# 恢复embedding到db

uuid = get_deviceid()

p = People.query.filter_by(aliyun_url=img_url, group_id=group_id).first()

if not p:

people = People(embed=embedding, uuid=uuid, group_id=group_id,

objId=faceid, aliyun_url=img_url, classId=faceid, style=style)

db.session.add(people)

db.session.commit()

print("Add people")

#return True

#else:

#print("No need add people")

#return False

old_train_set = TrainSet.query.filter_by(url=img_url, group_id=group_id).first() # 一张图片对应的人是唯一的

if not old_train_set:

new_train_set = TrainSet(url=img_url, group_id=group_id, is_or_isnot=True,

device_id='', face_id=faceid, filepath=filepath, drop=False, style=style)

db.session.add(new_train_set)

db.session.commit()

else:

if old_train_set.filepath != filepath:

print("Update filepath in local DB")

TrainSet.query.filter_by(url=img_url, group_id=group_id).update(dict(filepath=filepath))