def frames2batch(k=12, batch_size=1024, is_calib=False):
pos = util.get_files(rootdir='F:\\train_data\\pos\\')
neg = util.get_files(rootdir='F:\\train_data\\neg\\')
pos = shuffle(pos)
neg = shuffle(neg)
total = pos + neg
total = shuffle(total)
batch = []
c = 0
bpath = 'F:\\train_data\\batch\\'
for item_path in total:
frame = fr.get_frame(item_path)
frame_r = fr.resize_frame(frame, (k, k))
if frame_r == None:
continue
vec = fr.frame_to_vect(frame_r)
label = 1 if item_path.split('\\')[-1].find('pos') > 0 else 0
print(item_path, label)
batch.append((vec, label))
if len(batch) > 0 and len(batch) % batch_size == 0:
batch = sp.array(batch)
sp.savez(
bpath + str(c) + '_' + str(k) +
('_' if not is_calib else '_calib-') + 'net', batch)
batch = []
c += 1
if len(batch) > 0 and len(batch) % batch_size == 0:
batch = sp.array(batch)
sp.savez(
bpath + str(c) + '_' + str(k) +
('_' if not is_calib else '_calib') + '-net', batch)
batch = []
c += 1
def get_aflw_face_data(k = 12):
dbpath = 'F:\\datasets\\image_data_sets\\faces\\AFLW'
dbpath = join(dbpath,'aflw.sqlite')
rfpath = 'F:\\datasets\\image_data_sets\\faces\\AFLW\\img'
conn = sqlite3.connect(dbpath)
X = []
for file_id,x,y,h,w in conn.execute('SELECT file_id,x,y,h,w FROM Faces NATURAL JOIN FaceRect'):
fpath = join(rfpath,file_id)
frame = fr.get_frame(fpath)
no_neg = sp.all(sp.array([x,y,h,w]) > 0) ## ignore a bad data in sql table
if frame != None and no_neg:
face = fr.get_patch(frame,y,x,(h,w))
face_r,good_example = Datasets.sample_resize(face,k)
if good_example:
print('face:',fpath)
vec = fr.frame_to_vect(face_r)
X.append(vec)
face_flip = fr.flip_frame(face)
face_flip_r = fr.resize_frame(face_flip,(k,k))
vec = fr.frame_to_vect(face_flip_r)
X.append(vec)
#fr.write_frame('F:\\1\\'+'flip'+str(file_id),face_flip)
#fr.write_frame('F:\\1\\'+str(file_id),face)
X = sp.array(X)
y = sp.ones(len(X))
return X,y
def get_train_non_face_data(k = 12,write_to_disk = False):
'''
cut non-faces (negative examples) by pick random patch (if in not overlaped with any
face bbox from all images in dataset
return X - features
y - labels
cnt - count of examples
'''
X = []
root = 'F:\\Datasets\\image_data_sets\\non-faces'
pattern = "*.jpg"
for path, subdirs, files in os.walk(root):
for iname in files:
if fnmatch(iname, pattern):
ipath = os.path.join(path, iname)
img = fr.get_frame(ipath)
print('non_face:',ipath)
if img == None:
continue
H,W = img.shape[:2]
non_face = shuffle(fr.split_frame(img,wshape=(k,k)),random_state=42)[:25]
for e in non_face:
X.append(fr.frame_to_vect(e))
X = sp.array(X)
y = sp.zeros(len(X))
return X,y
def main():
iname = 'img/test/1226.jpg'
nn12 = Cnnl('12-net').load_model('12-net_lasagne_.pickle')
nn_calib12 = Cnnl('12-calib_net').load_model(
'12-calib_net_lasagne_.pickle')
nn24 = Cnnl(nn_name='24-net',
subnet=nn12).load_model('24-net_lasagne_.pickle')
nn_calib24 = Cnnl('24-calib_net').load_model(
'24-calib_net_lasagne_.pickle')
nn48 = Cnnl(nn_name='48-net',
subnet=nn24).load_model('48-net_lasagne_.pickle')
nn_calib48 = Cnnl('48-calib_net').load_model(
'48-calib_net_lasagne_.pickle')
image = fr.get_frame(iname)
p = 16
k = 1.18
bb = apply_12_net(image=image,
iname=iname,
nn=nn12,
p_level=p,
k=k,
debug=0)
bb = apply_calib_net(image=image, iname=iname, bb=bb, nn=nn_calib12)
bb = util.nms(bb, T=0.8)
bb = apply_24_net(image=image, iname=iname, bb=bb, nn=nn24)
bb = apply_calib_net(image=image, iname=iname, bb=bb, nn=nn_calib24)
bb = util.nms(bb, T=0.8)
bb = apply_48_net(image=image, iname=iname, bb=bb, nn=nn48)
bb = util.nms(bb, T=0.3)
bb = apply_calib_net(image=image, iname=iname, bb=bb, nn=nn_calib48)
draw_bboxes(iname, bb)
def frames2batch(k = 12,batch_size = 1024, is_calib = False):
pos = util.get_files(rootdir = 'F:\\train_data\\pos\\')
neg = util.get_files(rootdir = 'F:\\train_data\\neg\\')
pos = shuffle(pos)
neg = shuffle(neg)
total = pos + neg
total = shuffle(total)
batch = []
c = 0
bpath = 'F:\\train_data\\batch\\'
for item_path in total:
frame = fr.get_frame(item_path)
frame_r = fr.resize_frame(frame,(k,k))
if frame_r == None:
continue
vec = fr.frame_to_vect(frame_r)
label = 1 if item_path.split('\\')[-1].find('pos') > 0 else 0
print(item_path,label)
batch.append((vec,label))
if len(batch) > 0 and len(batch) % batch_size == 0:
batch = sp.array(batch)
sp.savez(bpath + str(c) + '_' + str(k) + ('_' if not is_calib else '_calib-') + 'net',batch)
batch = []
c += 1
if len(batch) > 0 and len(batch) % batch_size == 0:
batch = sp.array(batch)
sp.savez(bpath + str(c) + '_' + str(k) + ('_' if not is_calib else '_calib') + '-net',batch)
batch = []
c += 1
def get_aflw_face_data(k=12):
dbpath = 'F:\\datasets\\image_data_sets\\faces\\AFLW'
dbpath = join(dbpath, 'aflw.sqlite')
rfpath = 'F:\\datasets\\image_data_sets\\faces\\AFLW\\img'
conn = sqlite3.connect(dbpath)
X = []
for file_id, x, y, h, w in conn.execute(
'SELECT file_id,x,y,h,w FROM Faces NATURAL JOIN FaceRect'):
fpath = join(rfpath, file_id)
frame = fr.get_frame(fpath)
no_neg = sp.all(
sp.array([x, y, h, w]) > 0) ## ignore a bad data in sql table
if frame != None and no_neg:
face = fr.get_patch(frame, y, x, (h, w))
face_r, good_example = Datasets.sample_resize(face, k)
if good_example:
print('face:', fpath)
vec = fr.frame_to_vect(face_r)
X.append(vec)
face_flip = fr.flip_frame(face)
face_flip_r = fr.resize_frame(face_flip, (k, k))
vec = fr.frame_to_vect(face_flip_r)
X.append(vec)
#fr.write_frame('F:\\1\\'+'flip'+str(file_id),face_flip)
#fr.write_frame('F:\\1\\'+str(file_id),face)
X = sp.array(X)
y = sp.ones(len(X))
return X, y
def get_train_non_face_data(k=12, write_to_disk=False):
'''
cut non-faces (negative examples) by pick random patch (if in not overlaped with any
face bbox from all images in dataset
return X - features
y - labels
cnt - count of examples
'''
X = []
root = 'F:\\Datasets\\image_data_sets\\non-faces'
pattern = "*.jpg"
for path, subdirs, files in os.walk(root):
for iname in files:
if fnmatch(iname, pattern):
ipath = os.path.join(path, iname)
img = fr.get_frame(ipath)
print('non_face:', ipath)
if img == None:
continue
H, W = img.shape[:2]
non_face = shuffle(fr.split_frame(img, wshape=(k, k)),
random_state=42)[:25]
for e in non_face:
X.append(fr.frame_to_vect(e))
X = sp.array(X)
y = sp.zeros(len(X))
return X, y
def get_aflw_face_data(k = 12, on_drive = False):
dbpath = 'F:\\datasets\\image_data_sets\\faces\\AFLW'
dbpath = join(dbpath,'aflw.sqlite')
rfpath = 'F:\\datasets\\image_data_sets\\faces\\AFLW\\img'
conn = sqlite3.connect(dbpath)
X = []
c = 0
for file_id,x,y,ra,rb,theta in conn.execute('SELECT file_id,x,y,ra,rb,theta FROM Faces NATURAL JOIN FaceEllipse'):
fpath = join(rfpath,file_id)
frame = fr.get_frame(fpath)
x1,y1,x2,y2 = util.ellipse2bbox(a = ra, b = rb, angle = theta, cx = x, cy = y)
x = x1
y = y1
h = abs(y2-y1)
w = abs(x2-x1)
no_neg = sp.all(sp.array([x,y,h,w]) > 0) ## ignore a bad data in sql table
if frame != None and no_neg:
y,x,w,h = [int(e) for e in (y,x,w,h)]
face = fr.get_patch(frame,y,x,(w,h))
face_r,good_example = Datasets.sample_resize(face,k,k)
if good_example:
print('face:',fpath)
vec = fr.frame_to_vect(face_r)
if not on_drive:
X.append(vec)
face_flip_r = fr.flip_frame(face_r)
vec = fr.frame_to_vect(face_flip_r)
X.append(vec)
else:
for item in Datasets.data_augmentation(frame,y,x,w,h):
fr.write_frame('F:\\train_data\\pos\\' + str(c) + '_' + str(file_id)[:-4] + '_' + 'pos',item)
c +=1
X = sp.array(X)
y = sp.ones(len(X))
return X,y
def draw_bboxes(iname,bb):
debug = 1
image = fr.get_frame(iname)
marked_image = image.copy()
for box in bb:
x1,y1,x2,y2 = box
cv2.rectangle(marked_image, (x1, y1), (x2, y2), (64,0,192), 1)
if debug:
cv2.imwrite('result'+'_pipeline_rescale_image_' + '.jpg',marked_image)
else:
sns.plt.imshow(marked_image)
def draw_bboxes(iname, bb):
debug = 1
image = fr.get_frame(iname)
marked_image = image.copy()
for box in bb:
x1, y1, x2, y2 = box
cv2.rectangle(marked_image, (x1, y1), (x2, y2), (64, 0, 192), 1)
if debug:
cv2.imwrite('result' + '_pipeline_rescale_image_' + '.jpg',
marked_image)
else:
sns.plt.imshow(marked_image)
def get_train_wider_calib_data(n=None, k=12):
'''
for calibration net
return X - features
y - labels
cnt - count of examples
'''
X, y = [], []
sn = (0.83, 0.91, 1.0, 1.10, 1.21)
xn = (-0.17, 0.0, 0.17)
yn = (-0.17, 0.0, 0.17)
prod = [e for e in itertools.product(sn, xn, yn)]
inv_calib = lambda i, j, h, w, n: [
round(i - (-prod[n][1] * w / (prod[n][0]**-1))),
round(j - (-prod[n][2] * h / (prod[n][0]**-1))),
round(h / prod[n][0]**-1),
round(w / prod[n][0]**-1)
]
suff = str(k)
X_name = 'train_data_icalib_' + suff + '.npy'
y_name = 'labels_icalib_' + suff + '.npy'
root = 'F:\\Datasets\\image_data_sets\\faces\\WIDERFace\\'
pattern = "*.jpg"
bboxs = Datasets.load_wider_face(
os.path.join(root, 'wider_face_split', 'wider_face_train_v7.mat'))
for path, subdirs, files in os.walk(root, 'WIDER_train'):
for iname in files:
if fnmatch(iname, pattern):
ipath = os.path.join(path, iname)
img = fr.get_frame(ipath)
H, W = img.shape[:2]
bbox_list = bboxs[iname[:-4]]
for bbox in bbox_list:
label = sp.random.randint(0, 45)
i, j, h, w = [
int(e) for e in inv_calib(bbox[1], bbox[0],
bbox[2], bbox[3], label)
]
face = fr.get_patch(img, i, j, (h, w))
face_r, good_example = Datasets.sample_resize(face, k)
if good_example:
#print('orig:',bbox[1],bbox[0],bbox[2],bbox[3])
#print('inv_calib:',i,j,h,w)
vec_icalib = fr.frame_to_vect(face_r)
X.append(vec_icalib)
y.append(label)
print('face calib:', label, ipath)
y = sp.array(y)
sp.save(y_name, y)
X = sp.array(X)
sp.save(X_name, X)
return X, y
def draw_bboxes(iname,bb,c = 42,debug=0):
image = fr.get_frame(iname)
marked_image = image.copy()
for box in bb:
x1,y1,x2,y2 = box
cv2.rectangle(marked_image, (x1, y1), (x2, y2), (0,0,255), 1)
if debug:
cv2.imwrite('pipeline_' + str(c) + '.jpg',marked_image)
else:
marked_image = marked_image[...,::-1]
sns.plt.grid(False)
sns.plt.imshow(marked_image)
def get_train_calib_data(k = 12):
'''
for calibration net
return X - features
y - labels
cnt - count of examples
'''
sp.random.seed(42)
X_data,y_data = [],[]
suff = str(k)
c = 0
X_name = 'train_data_icalib_'+ suff + '.npz'
y_name = 'labels_icalib_'+ suff + '.npz'
label = -1
dbpath = 'F:\\datasets\\image_data_sets\\faces\\AFLW'
dbpath = join(dbpath,'aflw.sqlite')
rfpath = 'F:\\datasets\\image_data_sets\\faces\\AFLW\\img'
conn = sqlite3.connect(dbpath)
c = 0
for file_id,x,y,ra,rb,theta in conn.execute('SELECT file_id,x,y,ra,rb,theta FROM Faces NATURAL JOIN FaceEllipse'):
fpath = join(rfpath,file_id)
frame = fr.get_frame(fpath)
x1,y1,x2,y2 = util.ellipse2bbox(a = ra, b = rb, angle = theta, cx = x, cy = y)
x = x1
y = y1
h = abs(y2-y1)
w = abs(x2-x1)
no_neg = sp.all(sp.array([x,y,h,w]) > 0) ## ignore a bad data in sql table
if frame != None and no_neg:
y,x,w,h = [int(e) for e in (y,x,w,h)]
face = fr.get_patch(frame,y,x,(w,h))
#fr.write_frame('F:\\1\\' + str(c) + 'orig',face)
c += 1
for ((new_y,new_x,new_w,new_h),label) in [(util.calib(y,x,w,h,k),k) for k in sp.random.randint(0,45,5)]:
face = fr.get_patch(frame,new_y,new_x,(new_w,new_h))
no_neg_calib = sp.all(sp.array([new_x,new_y,new_h,new_w]) > 0)
face_r,good_example = Datasets.sample_resize(face,k,k)
if good_example and no_neg_calib:
#fr.write_frame('F:\\1\\' + str(c) + 'calib_'+str(label) ,face)
print('face:',fpath,label)
vec = fr.frame_to_vect(face_r)
X_data.append(vec)
y_data.append(label)
y_data = sp.array(y_data)
sp.savez(y_name,y_data)
X_data = sp.array(X_data)
sp.savez(X_name,X_data)
return X_data,y_data
def get_fddb_face_data(k = 12, on_drive = False):
root = 'F:\\datasets\\image_data_sets\\faces\\FDDB\\'
iroot = os.path.join(root,'originalPics')
eroot = os.path.join(root,'FDDB-folds')
pattern = '-ellipseList.txt'
c = 0
X,y = [],[]
for path, subdirs, files in os.walk(eroot):
for fname in files:
if fname.find(pattern) > 0:
fpath = os.path.join(path,fname)
print(fpath)
with open(fpath) as f:
lines = sp.array(f.readlines())
paths_indx = sp.where([line.find('/') > 0 for line in lines])[0]
counts_indx = paths_indx + 1
paths = sp.array([e.strip() for e in lines[paths_indx]])
ellipces = []
for i in counts_indx:
cnt = int(lines[i])
ellipces.append(lines[i+1:i+cnt+1])
ellipces = [ [ [float(num) for num in line.split()[:-1]] for line in e] for e in ellipces]
ellipces = sp.array(ellipces)
for iname,ells in zip(paths[:],ellipces[:]):
ppath = os.path.join(iroot,iname.replace('/','\\')) + '.jpg'
file_id = iname.split('/')[-1]
frame = fr.get_frame(ppath)
for item in ells:
ra,rb,theta,x,y = item
x1,y1,x2,y2 = util.ellipse2bbox(a = ra, b = rb, angle = theta, cx = x, cy = y)
x = x1
y = y1
h = abs(y2-y1)
w = abs(x2-x1)
print(file_id,(y,x,h,w))
non_neg = x > 0 and y > 0
if not non_neg:
continue
if on_drive:
for item in Datasets.data_augmentation(frame,y,x,w,h):
fr.write_frame('F:\\train_data\\pos\\' + str(c) + '_' + str(file_id) + '_pos',item)
c +=1
else:
pass
X = sp.array(X)
y = sp.ones(len(X))
return X,y
def get_aflw_face_data(k=12, on_drive=False):
dbpath = 'F:\\datasets\\image_data_sets\\faces\\AFLW'
dbpath = join(dbpath, 'aflw.sqlite')
rfpath = 'F:\\datasets\\image_data_sets\\faces\\AFLW\\img'
conn = sqlite3.connect(dbpath)
X = []
c = 0
for file_id, x, y, ra, rb, theta in conn.execute(
'SELECT file_id,x,y,ra,rb,theta FROM Faces NATURAL JOIN FaceEllipse'
):
fpath = join(rfpath, file_id)
frame = fr.get_frame(fpath)
x1, y1, x2, y2 = util.ellipse2bbox(a=ra,
b=rb,
angle=theta,
cx=x,
cy=y)
x = x1
y = y1
h = abs(y2 - y1)
w = abs(x2 - x1)
no_neg = sp.all(
sp.array([x, y, h, w]) > 0) ## ignore a bad data in sql table
if frame != None and no_neg:
y, x, w, h = [int(e) for e in (y, x, w, h)]
face = fr.get_patch(frame, y, x, (w, h))
face_r, good_example = Datasets.sample_resize(face, k, k)
if good_example:
print('face:', fpath)
vec = fr.frame_to_vect(face_r)
if not on_drive:
X.append(vec)
face_flip_r = fr.flip_frame(face_r)
vec = fr.frame_to_vect(face_flip_r)
X.append(vec)
else:
for item in Datasets.data_augmentation(
frame, y, x, w, h):
fr.write_frame(
'F:\\train_data\\pos\\' + str(c) + '_' +
str(file_id)[:-4] + '_' + 'pos', item)
c += 1
X = sp.array(X)
y = sp.ones(len(X))
return X, y
def get_train_face_wider_data(k=12, write_to_disk=False):
'''
cut faces (positive examples) by bboxes from all images in dataset
return X - features
y - labels
cnt - count of examples
'''
X, y = [], []
root = 'F:\\Datasets\\image_data_sets\\faces\\WIDERFace\\'
pattern = "*.jpg"
bboxs = Datasets.load_wider_face(
os.path.join(root, 'wider_face_split', 'wider_face_train_v7.mat'))
for path, subdirs, files in os.walk(root, 'WIDER_train'):
for indx, iname in enumerate(files):
if fnmatch(iname, pattern):
ipath = os.path.join(path, iname)
print('face:', ipath)
img = fr.get_frame(ipath)
H, W, dim = img.shape
bbox_list = bboxs[iname[:-4]]
for bbox in bbox_list:
face = fr.get_patch(img, bbox[1], bbox[0],
(bbox[2], bbox[3]))
#fr.write_frame('F:\\1\\' + str(c),face)
face_r, good_example = Datasets.sample_resize(
face, k, k)
if good_example:
vec = fr.frame_to_vect(face_r)
X.append(vec)
y.append(1)
face_r_flip = fr.flip_frame(face_r)
vec = fr.frame_to_vect(face_r_flip)
X.append(vec)
y.append(1)
X = sp.array(X)
y = sp.array(y)
#y = sp.ones(len(X))
return X, y
def get_train_wider_calib_data(n = None,k = 12):
'''
for calibration net
return X - features
y - labels
cnt - count of examples
'''
X,y = [],[]
sn = (0.83, 0.91, 1.0, 1.10, 1.21)
xn = (-0.17, 0.0, 0.17)
yn = (-0.17, 0.0, 0.17)
prod = [e for e in itertools.product(sn,xn,yn)]
inv_calib = lambda i,j,h,w,n: [ round(i-(-prod[n][1]*w/(prod[n][0]**-1))),round(j-(-prod[n][2]*h/(prod[n][0]**-1))),round(h/prod[n][0]**-1),round(w/prod[n][0]**-1) ]
suff = str(k)
X_name = 'train_data_icalib_'+ suff + '.npy'
y_name = 'labels_icalib_'+ suff + '.npy'
root = 'F:\\Datasets\\image_data_sets\\faces\\WIDERFace\\'
pattern = "*.jpg"
bboxs = Datasets.load_wider_face(os.path.join(root,'wider_face_split','wider_face_train_v7.mat'))
for path, subdirs, files in os.walk(root,'WIDER_train'):
for iname in files:
if fnmatch(iname, pattern):
ipath = os.path.join(path, iname)
img = fr.get_frame(ipath)
H,W = img.shape[:2]
bbox_list = bboxs[iname[:-4]]
for bbox in bbox_list:
label = sp.random.randint(0,45)
i,j,h,w = [int(e) for e in inv_calib(bbox[1],bbox[0],bbox[2],bbox[3],label)]
face = fr.get_patch(img,i,j,(h,w))
face_r,good_example = Datasets.sample_resize(face,k)
if good_example:
#print('orig:',bbox[1],bbox[0],bbox[2],bbox[3])
#print('inv_calib:',i,j,h,w)
vec_icalib = fr.frame_to_vect(face_r)
X.append(vec_icalib)
y.append(label)
print('face calib:',label,ipath)
y = sp.array(y)
sp.save(y_name,y)
X = sp.array(X)
sp.save(X_name,X)
return X,y
def get_train_non_face_data(k=12, patch_per_img=25, on_drive=False):
'''
cut non-faces (negative examples) by pick random patch (if in not overlaped with any
face bbox from all images in dataset
return X - features
y - labels
cnt - count of examples
'''
X = []
def yield_gen(data):
data = shuffle(data)[:patch_per_img]
for e in data:
yield e
root = 'F:\\Datasets\\image_data_sets\\non-faces'
pattern = "*.jpg"
c = 0
for path, subdirs, files in os.walk(root):
for iname in files:
if fnmatch(iname, pattern):
ipath = os.path.join(path, iname)
img = fr.get_frame(ipath)
print('non_face:', ipath)
if img == None:
continue
H, W = img.shape[:2]
if not on_drive:
for e in yield_gen(fr.split_frame(img, wshape=(k, k))):
X.append(fr.frame_to_vect(e))
else:
for e in yield_gen(
fr.split_frame(img,
wshape=(util.k_max,
util.k_max))):
fr.write_frame(
'F:\\train_data\\neg\\' + str(c) + '_'
'nonface' + '_neg', e)
c += 1
X = sp.array(X)
y = sp.zeros(len(X))
return X, y
def get_train_face_wider_data(k = 12,write_to_disk = False):
'''
cut faces (positive examples) by bboxes from all images in dataset
return X - features
y - labels
cnt - count of examples
'''
X,y = [],[]
root = 'F:\\Datasets\\image_data_sets\\faces\\WIDERFace\\'
pattern = "*.jpg"
bboxs = Datasets.load_wider_face(os.path.join(root,'wider_face_split','wider_face_train_v7.mat'))
for path, subdirs, files in os.walk(root,'WIDER_train'):
for indx,iname in enumerate(files):
if fnmatch(iname, pattern):
ipath = os.path.join(path, iname)
print('face:',ipath)
img = fr.get_frame(ipath)
H,W,dim = img.shape
bbox_list = bboxs[iname[:-4]]
for bbox in bbox_list:
face = fr.get_patch(img,bbox[1],bbox[0],(bbox[2],bbox[3]))
#fr.write_frame('F:\\1\\' + str(c),face)
face_r,good_example = Datasets.sample_resize(face,k,k)
if good_example:
vec = fr.frame_to_vect(face_r)
X.append(vec)
y.append(1)
face_r_flip = fr.flip_frame(face_r)
vec = fr.frame_to_vect(face_r_flip)
X.append(vec)
y.append(1)
X = sp.array(X)
y = sp.array(y)
#y = sp.ones(len(X))
return X,y
def main():
iname = 'img/test/1226.jpg'
nn12 = Cnnl('12-net').load_model('12-net_lasagne_.pickle')
nn_calib12 = Cnnl('12-calib_net').load_model('12-calib_net_lasagne_.pickle')
nn24 = Cnnl(nn_name = '24-net',subnet=nn12).load_model('24-net_lasagne_.pickle')
nn_calib24 = Cnnl('24-calib_net').load_model('24-calib_net_lasagne_.pickle')
nn48 = Cnnl(nn_name = '48-net',subnet=nn24).load_model('48-net_lasagne_.pickle')
nn_calib48 = Cnnl('48-calib_net').load_model('48-calib_net_lasagne_.pickle')
image = fr.get_frame(iname)
p = 16
k = 1.18
bb = apply_12_net(image = image,iname = iname,nn = nn12,p_level=p,k=k,debug=0)
bb = apply_calib_net(image = image, iname = iname,bb=bb,nn=nn_calib12)
bb = util.nms(bb,T=0.8)
bb = apply_24_net(image = image, iname = iname, bb = bb,nn = nn24 )
bb = apply_calib_net(image = image, iname = iname,bb = bb,nn=nn_calib24)
bb = util.nms(bb,T=0.8)
bb = apply_48_net(image = image, iname = iname, bb = bb,nn = nn48 )
bb = util.nms(bb,T=0.3)
bb = apply_calib_net(image = image, iname = iname,bb=bb,nn=nn_calib48)
draw_bboxes(iname,bb)
def get_train_non_face_data(k = 12,patch_per_img = 25,on_drive = False):
'''
cut non-faces (negative examples) by pick random patch (if in not overlaped with any
face bbox from all images in dataset
return X - features
y - labels
cnt - count of examples
'''
X = []
def yield_gen(data):
data = shuffle(data)[:patch_per_img]
for e in data:
yield e
root = 'F:\\Datasets\\image_data_sets\\non-faces'
pattern = "*.jpg"
c = 0
for path, subdirs, files in os.walk(root):
for iname in files:
if fnmatch(iname, pattern):
ipath = os.path.join(path, iname)
img = fr.get_frame(ipath)
print('non_face:',ipath)
if img == None:
continue
H,W = img.shape[:2]
if not on_drive:
for e in yield_gen(fr.split_frame(img,wshape=(k,k))):
X.append(fr.frame_to_vect(e))
else:
for e in yield_gen(fr.split_frame(img,wshape=(util.k_max,util.k_max))):
fr.write_frame('F:\\train_data\\neg\\' + str(c) + '_' 'nonface'+'_neg',e)
c += 1
X = sp.array(X)
y = sp.zeros(len(X))
return X,y
class Interpret:
string_reg = re.compile(r'^([^\\#\s]*(\\\d{3})*)*$')
int_reg = re.compile(r'^([+\-])*(\d)+')
def __init__(self, program_list):
# seznam instrukci vstupniho programu
self.program_list = program_list
# pocet vsech vykonanych instrukci
# (muze byt vyssi nez pocet instrukci ve vstupnim programu)
self.ins_cntr = 0
self.prog_cntr = 0 # poradi prave prochazene instrukce od 0
# seznam slovniku promennych v ramci GF,
# docasne tam budou vsechny promenne (TF i LF)
# slovnik promennych - jmeno:hodnota
self.frames = Frames(self.prog_cntr)
self.label_dict = {} # jmeno : poradi_instrukce
self.data_stack = [] # stack pro POPS a PUSHS
self.call_stack = []
# promenna pro skoky
# - interpret projde znovu program od mista, kam se skoci
self.again = True
# hlavni metoda interpretu
def interpret(self):
# Projde program a ulozi labely
for self.prog_cntr, val in enumerate(self.program_list):
self.opcode = self.program_list[self.prog_cntr][0]
if self.opcode == 'LABEL':
name = self.get_value_prog(1)
# kdyz neni label ve slovniku labelu, pridej ho tam
if name not in self.label_dict:
self.label_dict[name] = self.prog_cntr
else:
print("{}. instrukce, {}, pokus o redefinici navesti '{}'."
.format(self.prog_cntr+1, self.opcode, name), file=sys.stderr)
sys.exit(SEM_ERR)
# Hlavni cyklus vykovanani instrukci
self.prog_cntr = 0
start = 0 # misto kam se ma skocit
self.again = True
while self.again:
self.prog_cntr = 0
self.again = False
for self.prog_cntr, val in enumerate(self.program_list[start:], start = start):
#print(self.prog_cntr, val) #DEBUG
#print(program_list[self.prog_cntr][0]) #DEBUG
self.opcode = self.program_list[self.prog_cntr][0]
self.ins_cntr += 1
self.frames.update_prog_cntr(self.prog_cntr)
if self.opcode == 'LABEL':
pass
###############################################################
elif self.opcode == 'DEFVAR':
var = self.get_var_prog()
self.frames.get_frame(var) # zkontroluje jestli frame existuje
# deklarace promenne, ktera jeste neni deklarovana
if not self.is_var_declared(var):
self.declare_var(var)
###############################################################
elif self.opcode == 'MOVE':
symb_type = self.get_symb_type(2, True)
value = self.get_symb_value(2)
self.update_or_def_val(1, symb_type, value)
###############################################################
elif self.opcode == 'JUMP':
start = self.jump()
if self.again:
break
###############################################################
elif self.opcode == 'JUMPIFEQ':
start = self.jump_equality(operator.eq)
if self.again:
break
###############################################################
elif self.opcode == 'JUMPIFNEQ':
start = self.jump_equality(operator.ne)
if self.again:
break
###############################################################
elif self.opcode == 'WRITE':
symb_type = self.get_symb_type(1, True)
value = self.get_symb_value(1)
value = self.bool_to_str(symb_type, value)
print(value, file=sys.stdout)
elif self.opcode == 'DPRINT':
pass
###############################################################
elif self.opcode == 'CONCAT':
self.operator_3_args(operator.add,'string')
elif self.opcode == 'ADD':
self.operator_3_args(operator.add,'int')
elif self.opcode == 'SUB':
self.operator_3_args(operator.sub,'int')
elif self.opcode == 'MUL':
self.operator_3_args(operator.mul,'int')
elif self.opcode == 'IDIV':
self.operator_3_args(operator.floordiv,'int')
elif self.opcode == 'LT':
self.operator_3_args(operator.lt,'any')
elif self.opcode == 'GT':
self.operator_3_args(operator.gt,'any')
elif self.opcode == 'EQ':
self.operator_3_args(operator.eq,'any')
elif self.opcode == 'AND':
self.operator_3_args(operator.and_,'bool')
elif self.opcode == 'OR':
self.operator_3_args(operator.or_,'bool')
###############################################################
elif self.opcode == 'NOT':
self.op_not()
elif self.opcode == 'PUSHS':
symb_type = self.get_symb_type(1, True)
value = self.get_symb_value(1)
var_list = []
var_list.append(symb_type)
var_list.append(value)
self.data_stack.append(var_list)
###############################################################
elif self.opcode == 'POPS':
stack_len = len(self.data_stack)
if stack_len > 0:
value_list = self.data_stack.pop()
var_type = value_list[0]
value = value_list[1]
self.update_or_def_val(1, var_type, value)
else:
print("{}. instrukce, {}, datovy zasobnik je prazdny"
.format(self.prog_cntr+1, self.opcode), file=sys.stderr)
sys.exit(VALUE_MISSING)
###############################################################
elif self.opcode == 'TYPE':
arg_type = self.get_type_prog(2)
name = self.get_value_prog(2)
if arg_type == 'var':
if not self.is_var_declared(name):
self.not_declared_err(name)
# promenna nemusi byt definovana -> False
value = self.get_symb_type(2, False)
self.update_or_def_val(1, 'string', value)
###############################################################
elif self.opcode == 'READ':
exp_type = self.check_type_get_value(2, 'type')
try:
value = input()
except EOFError as error:
value = ''
if exp_type == 'int':
if re.match(self.int_reg, value):
value = int(value)
else:
value = 0
elif exp_type == 'bool':
val_lower = value.lower()
if val_lower in {'true','false'}:
value = self.str_to_bool('bool',val_lower)
else:
value = False
self.update_or_def_val(1, exp_type, value)
###############################################################
elif self.opcode == 'STRLEN':
value = self.check_type_get_value(2, 'string')
length = len(value)
self.update_or_def_val(1, 'int', length)
###############################################################
elif self.opcode == 'STRI2INT':
string = self.check_type_get_value(2, 'string')
index = self.check_type_get_value(3, 'int')
self.check_str_bounds(index, string)
char = string[index]
try:
ord_val = ord(char)
except TypeError as error:
print("{}. instrukce, {}, znak {} se nepodaril prevest na ordinalni hodnotu"
.format(self.prog_cntr+1, self.opcode, char), file=sys.stderr)
sys.exit(STR_ERR)
self.update_or_def_val(1, 'int', ord_val)
###############################################################
elif self.opcode == 'INT2CHAR':
value = self.check_type_get_value(2, 'int')
try:
char = chr(value)
except ValueError as error:
print("{}. instrukce, {}, hodnota {} neni validni ordinalni hodnota unicode"
.format(self.prog_cntr+1, self.opcode, value), file=sys.stderr)
sys.exit(STR_ERR)
self.update_or_def_val(1, 'string', char)
###############################################################
elif self.opcode == 'GETCHAR':
symb1_type = self.get_symb_type(2, True)
if symb1_type != 'string':
self.symb_type_err(2, 'string')
symb2_type = self.get_symb_type(3, True)
if symb2_type != 'int':
self.symb_type_err(3, 'int')
string = self.get_symb_value(2)
index = self.get_symb_value(3)
self.check_str_bounds(index, string)
char = string[index]
self.update_or_def_val(1, 'string', char)
###############################################################
elif self.opcode == 'SETCHAR':
to_change = self.check_type_get_value(1, 'string')
symb1_type = self.get_symb_type(2, True)
if symb1_type != 'int':
self.symb_type_err(2, 'int')
string = self.check_type_get_value(3, 'string')
if len(string) > 0:
char = string[0]
else:
print("{}.instrukce, {}, retezec ve 3. argumentu je prazdny"
.format(self.prog_cntr+1, self.opcode), file=sys.stderr)
sys.exit(STR_ERR)
index = self.get_symb_value(2)
self.check_str_bounds(index, to_change)
changed_str = to_change[:index] + char + to_change[index+1:]
self.update_or_def_val(1, 'string', changed_str)
###############################################################
elif self.opcode == 'BREAK':
print("Pozice v kodu: {}. instrukce, {}, pocet vykonanych instrukci: {}."
.format(self.prog_cntr+1, self.opcode, self.ins_cntr), file=sys.stderr)
print("Definovana navesti:\n{}"
.format(self.label_dict), file=sys.stderr)
print("\nGlobalni ramec:\n{}"
.format(self.frames.return_frame('GF')), file = sys.stderr)
print("\nLokalni ramec:\n{}"
.format(self.frames.return_frame('LF')), file = sys.stderr)
print("\nDocasny ramec:\n{}"
.format(self.frames.return_frame('TF')), file = sys.stderr)
print("\nDeklarovane promenne:\n{}"
.format(self.var_name_list), file = sys.stderr)
print("\nDatovy zasobnik:\n{}"
.format(self.data_stack), file = sys.stderr)
###############################################################
elif self.opcode == 'CREATEFRAME':
self.frames.create_frame()
elif self.opcode == 'PUSHFRAME':
self.frames.push_frame()
elif self.opcode == 'POPFRAME':
self.frames.pop_frame()
###############################################################
elif self.opcode == 'CALL':
label = self.check_type_get_value(1, 'label')
self.call_stack.append(self.prog_cntr)
start = self.jump()
if self.again:
break
elif self.opcode == 'RETURN':
# skoci az za CALL, jinak by se zacyklil
if len(self.call_stack) > 0:
start = self.call_stack.pop() + 1
self.again = True
break
else:
print("{}. instrukce, {}, zasobnik volani je prazdny"
.format(self.prog_cntr+1, self.opcode), file=sys.stderr)
sys.exit(VALUE_MISSING)
else:
print("{}. instrukce, neznama instrukce {}"
.format(self.prog_cntr+1, self.opcode), file=sys.stderr)
sys.exit(LEX_SYN_ERR)
########################################################################
########################################################################
# vykona instrukce se tremi argumenty, ktere vyzaduji pouziti nejakeho operatoru
# operator: definuje operaci mezi symboly
# arg_type: podporovany typ vsech argumentu
# (tam kde jsou libovolne je tato hodnota 'any')
def operator_3_args(self, operator, arg_type):
symb1_type = self.get_symb_type(2, True)
symb2_type = self.get_symb_type(3, True)
symb1_val = self.get_symb_value(2)
symb2_val = self.get_symb_value(3)
defined = False
if arg_type != 'any':
if symb1_type != arg_type or symb2_type != arg_type:
self.types_err(arg_type)
else:
if symb1_type != symb2_type:
self.same_types_err()
arg_type = 'bool'
try:
value = operator(symb1_val, symb2_val)
except ZeroDivisionError as error:
print("{}.instrukce, {}, deleni nulou."
.format(self.prog_cntr+1, self.opcode))
sys.exit(DIV_BY_ZERO_ERR)
# je potreba, protoze v ostatnich pripadech se hodnota ziskava ve forme retezce
self.update_or_def_val(1, arg_type, value)
# vykona instrukci NOT
def op_not(self):
symb_type = self.get_symb_type(2, True)
if symb_type != 'bool':
self.types_err('bool')
symb_val = self.get_symb_value(2)
value = not symb_val
self.update_or_def_val(1, 'bool', value)
# skoci na label
def jump(self):
start = 0
label = self.get_value_prog(1)
if label not in self.label_dict:
print("{}. instrukce, {}, skok na neexistujici navesti: {}."
.format(self.prog_cntr+1, self.opcode, label), file=sys.stderr)
sys.exit(SEM_ERR)
else:
# skoci az za label, aby nenastala chyba dvojite deklarace labelu
start = self.label_dict[label]+1
self.again = True
return start
# skoci na label v pripade, kdy vysledna hodnota vyrazu je vyhodnocena jako true
# operator - operace mezi temito dvema symboly
def jump_equality(self, operator):
start = 0
symb1_type = self.get_symb_type(2, True)
symb2_type = self.get_symb_type(3, True)
symb1_val = self.get_symb_value(2)
symb2_val = self.get_symb_value(3)
if symb1_type == symb2_type:
if operator(symb1_val, symb2_val):
start = self.jump()
else:
print("{}.instrukce, {}, nelze porovnat typ {} s {}."
.format(self.prog_cntr+1, self.opcode, symb1_type, symb2_type), file=sys.stderr)
sys.exit(OPER_TYPE_ERR)
return start
########################################################################
# ze vstupniho seznamu instrukci vraci nazev promenne (tedy prvni argument) dane instrukce
# napr z ['MOVE', {'var': 'GF@counter'}, {'string': None}] vrati GF@counter
def get_var_prog(self):
# var_dict - 'var' : jmeno
var_dict = self.program_list[self.prog_cntr][1]
var = var_dict['var']
return var
# Ze vstupniho seznamu instrukci vraci typ argumentu
def get_type_prog(self, arg_order):
type_dict = self.program_list[self.prog_cntr][arg_order]
if 'var' in type_dict:
var_type = 'var'
elif 'int' in type_dict:
var_type = 'int'
elif 'string' in type_dict:
var_type = 'string'
elif 'bool' in type_dict:
var_type = 'bool'
elif 'label' in type_dict:
var_type = 'label'
elif 'type' in type_dict:
var_type = 'type'
else:
print("Neexistujici typ.",file=sys.stderr)
sys.exit(LEX_SYN_ERR)
return var_type
# Ze vstupniho seznamu instrukci vraci hodnotu argumentu
# arg_order - poradi argumentu prave vyhodnocovane instrukce
def get_value_prog(self,arg_order):
var_type = self.get_type_prog(arg_order)
value_dict = self.program_list[self.prog_cntr][arg_order]
value = value_dict[var_type]
value = self.str_to_int(var_type, value)
value = self.str_to_bool(var_type, value)
if var_type == 'string':
if value is None:
value = ''
else:
value = self.convert_esc_seq(value)
return value
########################################################################
# vraci typ argumentu ze slovniku promenne (ze seznamu ramce)
# var_dict - slovnik promenne: {jmeno : typ}
def var_type_dict(self, var_dict):
if 'int' in var_dict:
var_type = 'int'
elif 'string' in var_dict:
var_type = 'string'
elif 'bool' in var_dict:
var_type = 'bool'
elif 'type' in var_dict:
var_type = 'type'
else:
print("Neexistujici typ promenne.",file=sys.stderr)
sys.exit(LEX_SYN_ERR)
return var_type
# vraci hodnotu promenne ze slovniku promenne
# var_dict - slovnik promenne: {jmeno : typ}
def get_var_value(self, var_dict):
var_type = self.var_type_dict(var_dict)
value = var_dict[var_type]
return value
# konvertuje escape sekvenci na ASCII znak
def convert_esc_seq(self, value):
new_str = value
esc_reg = re.compile(r'\\\d{3}')
all_esc = re.findall(esc_reg, value)
for esc in all_esc:
try:
string = chr(int(esc.lstrip('\\')))
new_str = new_str.replace(esc, string)
except TypeError as error:
print("{}.instrukce, {}, escape sekvence {} se nepodarila prevest na znak unicode."
.format(self.prog_cntr+1, self.opcode, esc), file=sys.stderr)
sys.exit(LEX_SYN_ERR)
return new_str
########################################################################
# V programu na indexu instrukce self.prog_cntr najde argument v poradi arg_order
# a vrati jeho hodnotu.
# V pripade promenne vraci hodnotu promenne z daneho framu (listu).
# arg_order - poradi argumentu prave vyhodnocovane instrukce
def get_value(self, arg_order):
var_type = self.get_type_prog(arg_order)
value = self.get_value_prog(arg_order)
if var_type == 'var':
frame = self.frames.get_frame(value)
value = self.without_frame(value)
defined = False
for var_list in frame:
if value in var_list:
if len(var_list) != 2:
self.not_defined_err(value)
var_dict = var_list[1]
value = self.get_var_value(var_dict)
defined = True
break
if not defined:
self.not_defined_err(value)
return value
# v danem ramci aktualizuje hodnotu a typ promenne
# arg_order - poradi argumentu prave vyhodnocovane instrukce
# var_dict - slovnik promenne: {jmeno : typ}
def update_value(self, arg_order, var_dict):
symb_type = self.get_type_prog(arg_order)
if symb_type != 'var':
return False
name = self.get_value_prog(arg_order)
frame = self.frames.get_frame(name)
name = self.without_frame(name)
defined = False
for var_list in frame:
if var_list[0] == name:
if len(var_list) == 2:
var_list.pop()
var_list.append(var_dict)
defined = True
if not defined:
self.not_defined_err(name)
# vraci typ promenne z jejiho ramce
# v pripade instrukce TYPE je pri nenalezeni typu vracen prazdny retezec
# arg_order - poradi argumentu prave vyhodnocovane instrukce
def get_var_type(self, arg_order, exit_error):
# var symb_type value
#frame = [['GF@retezec', {'string': ahoj}]]
# | |--------------|| var_dict
# |------------------------------| var_list
symb_type = self.get_type_prog(arg_order)
if symb_type != 'var':
return False
name = self.get_value_prog(arg_order)
frame = self.frames.get_frame(name)
name = self.without_frame(name)
for var_list in frame:
if var_list[0] == name:
if len(var_list) == 2:
var_dict = var_list[1]
ret_type = self.var_type_dict(var_dict)
else:
self.not_defined_err(name)
return ret_type
if exit_error:
self.not_defined_err(name)
else:
return '' # pro instrukci TYPE
# vrati hodnotu symbolu (promenne i konstanty)
# arg_order - poradi argumentu prave vyhodnocovane instrukce
def get_symb_value(self, arg_order):
symb_type = self.get_type_prog(arg_order)
if symb_type == 'var':
symb_val = self.get_value(arg_order)
else:
symb_val = self.get_value_prog(arg_order)
return symb_val
# vrati typ symbolu
# arg_order - poradi argumentu prave vyhodnocovane instrukce
def get_symb_type(self,arg_order, exit_error):
symb_type = self.get_type_prog(arg_order)
if symb_type == 'var':
symb_type = self.get_var_type(arg_order, exit_error)
return symb_type
# zjisti typ symbolu a zkontroluje, jestli je spravny
# v pripade uspechu vraci hodnotu tohoto symbolu
# arg_order - poradi argumentu prave vyhodnocovane instrukce
# exp_type - spravny (ocekavany) typ symbolu
def check_type_get_value(self, arg_order, exp_type):
symb_type = self.get_symb_type(arg_order, True)
if symb_type != exp_type:
self.symb_type_err(arg_order, exp_type)
else:
return self.get_symb_value(arg_order)
# v pripade definovane promenne ji aktualizuje, jinak definuje
# arg_order - poradi argumentu prave vyhodnocovane instrukce
def update_or_def_val(self, arg_order, exp_type, value):
defined = False
if self.is_var_defined(arg_order):
var_dict = {exp_type : value}
self.update_value(arg_order, var_dict)
else:
self.define_undecl_var(arg_order, exp_type, value)
# vraci True pokud je promenna definovana, jinak False
# arg_order - poradi argumentu prave vyhodnocovane instrukce
def is_var_defined(self, arg_order):
name = self.get_value_prog(arg_order)
frame = self.frames.get_frame(name)
name = self.without_frame(name)
for var_list in frame:
if var_list[0] == name and len(var_list) == 2:
return True
return False
# z promenne odstrani prvni tri znaky (tedy GF@)
# pozor na nazvy promennych zacinajici na G|T|LF@
# - tato hodnota by byla take odstranena
# var - nazev promenne
def without_frame(self, var):
if var.startswith('GF@') or var.startswith('LF@') or var.startswith('TF@'):
return var[3:]
# najde index promenne v danem ramci
# v pripade neuspechu vraci -1
# var - nazev promenne
# frame - ramec (seznam)
def find_var_index(self, var, frame):
for index, var_list in enumerate(frame):
if var_list[0] == var:
return index
return -1
# definuje promennou
# var - jmeno promenne
# symb_type - typ promenne
# value - prirazena hodnota
def define_var(self, var, symb_type, value):
frame = self.frames.get_frame(var)
var = self.without_frame(var)
index = self.find_var_index(var, frame)
var_dict = {symb_type : value}
frame[index].append(var_dict)
# definuje deklarovanou promennou
# arg_order - poradi argumentu prave vyhodnocovane instrukce
# var_type - typ promenne
# value - hodnota
def define_undecl_var(self, arg_order, var_type, value):
var = self.get_var_prog()
if self.is_var_declared(var):
self.define_var(var, var_type, value)
else:
self.not_declared_err(var)
########################################################################
# ladici vystup pro vypis vstupniho programu
def print_program(self):
for index, val in enumerate(self.program_list):
print(index, val)
print("--------------------------------------------------------")
# v pripade, ze je promenna var deklarovana, vraci True, jinak False
# var - nazev promenne i s ramcem
def is_var_declared(self, var):
frame = self.frames.get_frame(var)
var = self.without_frame(var)
index = self.find_var_index(var, frame)
if index == -1:
return False
else:
return True
# deklaruje promennou
# var - nazev promenne i s ramcem
def declare_var(self,var):
frame = self.frames.get_frame(var)
var = self.without_frame(var)
var_list = []
var_list.append(var)
frame.append(var_list)
# konvertuje bool hodnotu IPPcode18 na bool hodnoty pythonu
# arg_type - typ symbolu
# value - hodnota
def str_to_bool(self, arg_type, value):
if arg_type == 'bool':
if value == 'true':
value = True
else:
value = False
return value
# konvertuje bool hodnotu pythonu na hodnotu IPPcode18
# arg_type - typ symbolu
# value - hodnota
def bool_to_str(self, arg_type, value):
if arg_type == 'bool':
if value == True:
value = 'true'
else:
value = 'false'
return value
# prevede cislo ulozene v retezci na cele cislo srozumitelne pythonem
# arg_type - typ symbolu
# value - hodnota
def str_to_int(self, arg_type, value):
if arg_type == 'int':
value = int(value)
return value
# zkontroluje, jestli se na indexu v retezci naleza nejaka hodnota
# index - poradi znaku v retezci (od 0)
# string - retezec
def check_str_bounds(self, index, string):
length = len(string)
if index >= length or index < 0:
print("{}.instrukce, {}, index {} je mimo velikost retezce {}"
.format(self.prog_cntr+1, self.opcode, index, string), file=sys.stderr)
sys.exit(STR_ERR)
########################################################################################
# vypise chybove hlaseni spatneho typu symbolu a skonci s chybou
# arg_order - poradi argumentu v instrukci
# symb_type - typ symbolu
def symb_type_err(self, arg_order, symb_type):
print("{}.instrukce, {}, {}. argument musi byt typu {}."
.format(self.prog_cntr+1, self.opcode, arg_order, symb_type), file=sys.stderr)
sys.exit(OPER_TYPE_ERR)
# vypise chybove hlaseni nedefinovane promenne a skonci s chybou
# var - jmeno promenne
def not_defined_err(self, var):
print("{}. instrukce, {}, promenna {} neni definovana."
.format(self.prog_cntr+1, self.opcode, var), file=sys.stderr)
sys.exit(VALUE_MISSING)
# vypise chybove hlaseni nedeklarovane promenne a skonci s chybou
# var - jmeno promenne
def not_declared_err(self,var):
print("{}. instrukce, {}, promenna {} neni deklarovana."
.format(self.prog_cntr+1, self.opcode, var), file=sys.stderr)
sys.exit(VAR_NOT_EXISTS_ERR)
# vypise chybove hlaseni nekompatibility typu s instrukci
# symb_type - typ symbolu
def types_err(self, symb_type):
print("{}.instrukce, {} podporuje pouze typ {}."
.format(self.prog_cntr+1, self.opcode, symb_type), file=sys.stderr)
sys.exit(OPER_TYPE_ERR)
# vypise chybove hlaseni v pripade odlisnych typu instrukce vyzadujici stejne typy symbolu (napr. ADD)
def same_types_err(self):
print("{}.instrukce, symboly {} musi byt stejneho typu."
.format(self.prog_cntr+1, self.opcode), file=sys.stderr)
sys.exit(OPER_TYPE_ERR)
def main():
iname = 'img/test/p1.jpg'
nn12 = Cnnl('12-net').__load_model_old__('12-net_lasagne_.pickle')
nn24 = Cnnl(nn_name = '24-net',subnet=nn12).__load_model_old__('24-net_lasagne_.pickle')
nn48 = Cnnl(nn_name = '48-net',subnet=nn24).__load_model_old__('48-net_lasagne_.pickle')
nn_calib12 = Cnnl('12-calib_net').__load_model_old__('12-calib_net_lasagne_.pickle')
nn_calib24 = Cnnl('24-calib_net').__load_model_old__('24-calib_net_lasagne_.pickle')
#nn_calib48 = Cnnl('48-calib_net').__load_model_old__('48-calib_net_lasagne_.pickle')
image = fr.get_frame(iname)
p = 11
k = 1.41
t_level = 0
gbb = []
gp = []
print('Start....')
s = time()
py = fr.get_frame_pyramid(image,scale=k,steps=p)
for m,frame in enumerate(py):
if m < t_level:
continue
bb,p = apply_12_net(image = image,frame=frame,iname = iname,nn = nn12,m=m,debug=0)
keep = util.nms(bb,p,T=0.5)
bb = bb[keep] if keep != [] else bb
p = p[keep] if keep != [] else p
cnt_detect = len(bb)
if cnt_detect == 0:
continue
#draw_bboxes(iname,bb,c='#-r_12--' + str(m))
for b in bb:
gbb.append(b)
for pp in p:
gp.append(pp)
gbb = sp.array(gbb)
gp = sp.array(gp)
#draw_bboxes(iname,gbb,c='0-r_12')
bb = gbb
p = gp
bb = apply_calib_net(image = image, iname = iname,bb=bb,nn=nn_calib12)
cnt_detect = len(bb)
#draw_bboxes(iname,bb,c='1-r_calib_12')
keep = util.nms(bb,p,T=0.3)
bb = bb[keep] if keep != [] else bb
p = p[keep] if keep != [] else p
#draw_bboxes(iname,bb,c='2-r_nms_12')
bb,p = apply_24_48_net(image = image, iname = iname, bb = bb,nn = nn24,debug=0 )
cnt_detect = len(bb)
#draw_bboxes(iname,bb,c='3-r_24')
bb = apply_calib_net(image = image, iname = iname,bb = bb,nn=nn_calib24)
cnt_detect = len(bb)
#draw_bboxes(iname,bb,c='4-r_calib_24')
keep = util.nms(bb,p,T=0.3)
bb = bb[keep] if keep != [] else bb
p = p[keep] if keep != [] else p
#draw_bboxes(iname,bb,c='5-r_nms_24')
cnt_detect = len(bb)
bb,p = apply_24_48_net(image = image, iname = iname, bb = bb,nn = nn48,debug=1)
cnt_detect = len(bb)
draw_bboxes(iname,bb,c='6-r_48',debug=1)
# bb = apply_calib_net(image = image,iname = iname,bb=bb,nn=nn_calib48)
# draw_bboxes(iname,bb,c='6-r_calib_48')
#
# bb = util.nms(bb,T=0.2)
# draw_bboxes(iname,bb,c='7-r_nms_48_final')
print('Finish...',time()-s)
def get_fddb_face_data(k=12, on_drive=False):
root = 'F:\\datasets\\image_data_sets\\faces\\FDDB\\'
iroot = os.path.join(root, 'originalPics')
eroot = os.path.join(root, 'FDDB-folds')
pattern = '-ellipseList.txt'
c = 0
X, y = [], []
for path, subdirs, files in os.walk(eroot):
for fname in files:
if fname.find(pattern) > 0:
fpath = os.path.join(path, fname)
print(fpath)
with open(fpath) as f:
lines = sp.array(f.readlines())
paths_indx = sp.where(
[line.find('/') > 0 for line in lines])[0]
counts_indx = paths_indx + 1
paths = sp.array(
[e.strip() for e in lines[paths_indx]])
ellipces = []
for i in counts_indx:
cnt = int(lines[i])
ellipces.append(lines[i + 1:i + cnt + 1])
ellipces = [[[float(num) for num in line.split()[:-1]]
for line in e] for e in ellipces]
ellipces = sp.array(ellipces)
for iname, ells in zip(paths[:], ellipces[:]):
ppath = os.path.join(iroot, iname.replace(
'/', '\\')) + '.jpg'
file_id = iname.split('/')[-1]
frame = fr.get_frame(ppath)
for item in ells:
ra, rb, theta, x, y = item
x1, y1, x2, y2 = util.ellipse2bbox(a=ra,
b=rb,
angle=theta,
cx=x,
cy=y)
x = x1
y = y1
h = abs(y2 - y1)
w = abs(x2 - x1)
print(file_id, (y, x, h, w))
non_neg = x > 0 and y > 0
if not non_neg:
continue
if on_drive:
for item in Datasets.data_augmentation(
frame, y, x, w, h):
fr.write_frame(
'F:\\train_data\\pos\\' + str(c) +
'_' + str(file_id) + '_pos', item)
c += 1
else:
pass
X = sp.array(X)
y = sp.ones(len(X))
return X, y
def get_train_calib_data(k=12):
'''
for calibration net
return X - features
y - labels
cnt - count of examples
'''
sp.random.seed(42)
X_data, y_data = [], []
suff = str(k)
c = 0
X_name = 'train_data_icalib_' + suff + '.npz'
y_name = 'labels_icalib_' + suff + '.npz'
label = -1
dbpath = 'F:\\datasets\\image_data_sets\\faces\\AFLW'
dbpath = join(dbpath, 'aflw.sqlite')
rfpath = 'F:\\datasets\\image_data_sets\\faces\\AFLW\\img'
conn = sqlite3.connect(dbpath)
c = 0
for file_id, x, y, ra, rb, theta in conn.execute(
'SELECT file_id,x,y,ra,rb,theta FROM Faces NATURAL JOIN FaceEllipse'
):
fpath = join(rfpath, file_id)
frame = fr.get_frame(fpath)
x1, y1, x2, y2 = util.ellipse2bbox(a=ra,
b=rb,
angle=theta,
cx=x,
cy=y)
x = x1
y = y1
h = abs(y2 - y1)
w = abs(x2 - x1)
no_neg = sp.all(
sp.array([x, y, h, w]) > 0) ## ignore a bad data in sql table
if frame != None and no_neg:
y, x, w, h = [int(e) for e in (y, x, w, h)]
face = fr.get_patch(frame, y, x, (w, h))
#fr.write_frame('F:\\1\\' + str(c) + 'orig',face)
c += 1
for ((new_y, new_x, new_w, new_h),
label) in [(util.calib(y, x, w, h, k), k)
for k in sp.random.randint(0, 45, 5)]:
face = fr.get_patch(frame, new_y, new_x, (new_w, new_h))
no_neg_calib = sp.all(
sp.array([new_x, new_y, new_h, new_w]) > 0)
face_r, good_example = Datasets.sample_resize(face, k, k)
if good_example and no_neg_calib:
#fr.write_frame('F:\\1\\' + str(c) + 'calib_'+str(label) ,face)
print('face:', fpath, label)
vec = fr.frame_to_vect(face_r)
X_data.append(vec)
y_data.append(label)
y_data = sp.array(y_data)
sp.savez(y_name, y_data)
X_data = sp.array(X_data)
sp.savez(X_name, X_data)
return X_data, y_data
