def recognize(cf, img):
# caricamento dei vari dataset
gallery_target = np.load("npy_db/gallery_target.npy")
histogram_gallery_data = np.load("npy_db/histogram_gallery_data.npy")
gallery_thresholds = np.load("npy_db/gallery_thresholds.npy")
users = pd.read_csv('dataset_user.csv', index_col=[0])
cf_list = users['Codice Fiscale']
# controlla se l'utente esiste
if not cf_list.tolist().__contains__(cf):
print("UTENTE NON PRESENTE! Il codice fiscale inserito è:", cf)
return None, 0, None
# inizializzazione delle variabili che conterranno i dati del paziente e l'indice in cui si trova in dataset_user
user = None
index = cf_list.tolist().index(cf)
# l'immagine in input viene normalizzata per poter utilizzare LBP e ottenerne l'istogramma relativo
norm_image = cv2.normalize(img, None, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)
norm_image = norm_image.astype(np.uint8)
lbp = LBP.Local_Binary_Pattern(1, 8, norm_image)
hist = lbp.createHistogram(lbp.compute_lbp())
# calcola la corrispondenza massima tra l'istogramma dell'immagine in input e quelli delle immagini nella galleria dell'utente
val = topMatch(cf, gallery_target, histogram_gallery_data, hist)
# se la similairtà massima è maggiore o uguale alla soglia adattativa del paziente, l'identità viene verificata
if val >= gallery_thresholds[index]:
user = users.iloc[index]
# ritorna le informazioni del paziente e l'indice in cui si trova in dataset_user
return user, index, user
def identify(cf, img):
# caricamento dei vari dataset
gallery_target = np.load("npy_db/gallery_target.npy")
histogram_gallery_data = np.load("npy_db/histogram_gallery_data.npy")
users = pd.read_csv('dataset_user.csv', index_col=[0])
gallery_thresholds = np.load("npy_db/gallery_thresholds.npy")
galley_users = list(dict.fromkeys(gallery_target))
cf_list = users['Codice Fiscale']
# controlla se l'utente esiste
if not cf_list.tolist().__contains__(cf):
print("UTENTE NON PRESENTE! Il codice fiscale inserito è:", cf)
return None, 0, None
# informazioni del paziente utilizzando cf
index = cf_list.tolist().index(cf)
user = users.iloc[index]
# lista dei delegati del paziente
delegati = ast.literal_eval(user["Delegati"])
# se il paziente non ha nessun delegato, allora termina l'operazione
if len(delegati) == 0:
print("L'utente non ha delegati!")
return None, 0, None
# si inizializzano le variabili per la similarity e l'identità del delegato
max = 0
identity = None
# l'immagine in input viene normalizzata per poter utilizzare LBP e ottenerne l'istogramma relativo
norm_image = cv2.normalize(img, None, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_32F)
norm_image = norm_image.astype(np.uint8)
lbp = LBP.Local_Binary_Pattern(1, 8, norm_image)
hist = lbp.createHistogram(lbp.compute_lbp())
# per ogni delegato
for d in delegati:
# ottengo il miglior valore ottenuto confrontando l'istograma con quelli del delegato nella galleria
val = topMatch(d, gallery_target, histogram_gallery_data, hist)
th_index = galley_users.index(d)
# confrontiamo la similarity con quella massimo ottenuta finora e con il threshold del delegato
# se la similarity supera quella massima e il threshold, allora aggiorniamo le variabili
if val > max and val >= gallery_thresholds[th_index]:
max = val # il più alto valore di similarity attuale
identity = d # identità del delegato che ha ottenuto il miglior valore per il momento
# se c'è stato un riconoscimento tra i delegati
if identity is not None:
indexd = cf_list.tolist().index(identity)
recUser = users.iloc[indexd]
# ritorna i dati del paziente, l'indice in cui si trova in dataset_user e le informazioni del delegato
return user, index, recUser
else:
# altrimenti ritorna None come paziente, 0 come indice e None come delegato
return None, 0, None
def convert_image_to_hist(self, image):
print(image)
image = cv2.imread(image)
norm_image = get_normalized(image)
myLBP = LBP.Local_Binary_Pattern(1, 8, norm_image)
new_img = myLBP.compute_lbp()
hist = myLBP.createHistogram(new_img)
return hist
def split_gallery_probe(self, data, target, cfs):
num_user = self.num_user(target)
# calcola il numero di template per utente
unique, counts = np.unique(target, return_counts=True)
occurrences = dict(zip(unique, counts))
# numero di utenti che non sono nella gallery
pn_user = round(num_user * pn / 100)
# conteggio dei template
countTemp = 0
# conteggio
countUser = 0
# gallery_target, gallery_data, pn_data, pn_target, pg_data, pg_target = [], [], [], [], [], []
gallery_target, gallery_data, pn_data, pn_target, pg_data, pg_target, histogram_gallery_data, \
histogram_pg_data, histogram_pn_data = [], [], [], [], [], [], [], [], []
# prendo il numero di template dell'utente. si parte dal presupposto che tutti gli utenti
# hanno lo stesso numero di template
occ = occurrences[target[0]]
# numero di template per il probe set
self.n_template_x_user = round(occ * probe / 100)
# per ogni utente
for i, val in enumerate(target):
name = cfs[countUser]
norm_template = self.get_normalized_template(i, data)
lbp = LBP.Local_Binary_Pattern(1, 8, norm_template)
# se il numero del template e' minore del numero massimo di template destinati alla gallery
# e il numero di utenti rientra negli utenti che sono nella gallery, allora inserisco il template nella
# gallery
if (countTemp < occ - self.n_template_x_user
or occ == 1) and countUser < num_user - pn_user:
gallery_data.append(norm_template)
gallery_target.append(name)
histogram_gallery_data.append(
lbp.createHistogram(lbp.compute_lbp()))
else:
# se lo inserisco nel probe set, controllo se l'utente e' nella gallery o no
if countUser < num_user - pn_user:
pg_data.append(norm_template)
pg_target.append(name)
histogram_pg_data.append(
lbp.createHistogram(lbp.compute_lbp()))
else:
pn_data.append(norm_template)
pn_target.append(name)
histogram_pn_data.append(
lbp.createHistogram(lbp.compute_lbp()))
countTemp += 1
# se ho finito i template dell'utente, passo all'utente successivo
if countTemp == occ:
countTemp = 0
countUser += 1
return gallery_data, gallery_target, pn_data, pn_target, pg_data, pg_target, histogram_gallery_data, histogram_pg_data, histogram_pn_data
def microTextureVideo(self, pathVid):
cap = cv2.VideoCapture(pathVid)
val = False
# andiamo a prendere un frame e lo convertiamo in scala di grigi.
while True:
ret, frame = cap.read()
try:
vis = frame.copy()
except Exception as e:
print(str(e))
break
# convertiamo in scala di grigi.
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# effettuiamo il ritaglio del viso
crop = detect_face(gray, vis)
# qui effettuiamo la conversione dell'immagine croppata in LBP
if crop is not None:
myLBP = LBP.Local_Binary_Pattern(1, 8, crop)
else:
continue
new_img = myLBP.compute_lbp()
# creiamo l'histogram dell'immagine calcolata in lpb
hist = myLBP.createHistogram(new_img)
# Andiamo a prendere il modello trained e salvato.
with open('modelSVM.pkl', 'rb') as f:
clf = pickle.load(f)
hist = hist.reshape(1, -1)
# attraverso il classificatore che abbiamo recuperato, ci facciamo dire se l'immagine è reale oppure no
value = (clf.predict(hist))
print(value)
if value == 0:
print("REAL")
val = True
break
else:
print("FAKE")
val = False
break
cap.release()
cv2.destroyAllWindows()
return val