def extractGlobalReferences(self, img): image = cv2.imread(img) filename = utils.getFilename(img) W, H, c = image.shape base = np.zeros((W, H), 'uint8') segmented = np.zeros((W, H, 3), 'uint8') segmented[..., 0] = base.copy() segmented[..., 1] = base.copy() segmented[..., 2] = base.copy() + 255 segmentedPath = config.temp_folder + 'global_segmented.png' cv2.imwrite(segmentedPath, segmented) illuminantMaps.estimateGrayEdge(img, segmentedPath, config.temp_folder, self.verbose) illuminantMaps.estimateGrayWorld(img, segmentedPath, config.temp_folder, self.verbose) illuminantMaps.estimateMaxRGB(img, segmentedPath, config.temp_folder, self.verbose) illuminantMaps.estimateShadesOfGray(img, segmentedPath, config.temp_folder, self.verbose) illuminantMaps.estimateSecondGrayEdge(img, segmentedPath, config.temp_folder, self.verbose) global_references = {} for alg in self.algorithms: global_references[alg] = utils.evaluateRGBMedian( config.temp_folder + filename + "_gge_map_" + alg + ".png")[0] return global_references
def extractDescriptor(img, descriptor, space=0, channel=3): filename = utils.getFilename(img) descriptorName = config.faces_folder + filename + "-" + descriptor.lower( ) + "-desc.txt" nname = img newName = nname[:-3] + "ppm" sourceImg = cv2.imread(img) if space == 0: destImg = cv2.cvtColor(sourceImg, cv2.COLOR_BGR2HSV) elif space == 1: destImg = cv2.cvtColor(sourceImg, cv2.COLOR_BGR2RGB) elif space == 2: destImg = cv2.cvtColor(sourceImg, cv2.COLOR_BGR2YCR_CB) elif space == 4: destImg = cv2.cvtColor(sourceImg, cv2.COLOR_BGR2LAB) else: destImg = sourceImg cv2.imwrite(nname, destImg) command = config.convertBinary + " " + nname + " " + newName subprocess.call([command], stdout=devnull, shell=True) command = "descriptors/" + descriptor.lower( ) + "/source/bin/./" + descriptor.lower( ) + "_extraction " + newName + " " + descriptorName if descriptor.lower() == 'sasi' or descriptor.lower( ) == 'las' or descriptor.lower() == 'unser': command += ' 1' subprocess.call([command], stdout=devnull, shell=True)
def extractIlluminationMaps(self, img): filename = utils.getFilename(img) illuminantMaps.prepareImageIlluminants( img, config.seg_sigma, config.seg_k, config.seg_min_size, config.min_intensity, config.max_intensity, self.verbose) if 'GGE' in config.illuminantTypes: illuminantMaps.extractGGEMap( img, config.maps_folder + filename + "_segmented.png", config.gge_sigma, config.gge_n, config.gge_p, self.verbose) if 'IIC' in config.illuminantTypes: illuminantMaps.extractIICMap( img, config.maps_folder + filename + "_segmented.png", self.verbose)
def getTrainingData(self, images, descriptor, illum='GGE'): trainingData = [] trainingLabels = [] trainingSource = [] for i in range(len(images)): filename = utils.getFilename(images[i]) path = config.features_folder + filename + '_' + illum + "_" + descriptor.lower( ) + ".txt" if os.path.isfile(path): imageFeatures = open(path, "r") features = [ FaceTrainingSample.fromTxt(pair) for pair in imageFeatures.read().splitlines() ] for sample in features: trainingLabels.append(sample.label) #pairData = [float(val) for val in list()] trainingData.append( np.array(sample.feature.split(), dtype=float)) trainingSource.append(utils.getFilename(path)) return np.asarray(trainingData), np.asarray( trainingLabels), np.asarray(trainingSource)
def evaluateEuclideanDistances(self, images): # Extract image features from each images in training set for i in range(len(images)): img = images[i] #if self.extract_features: # self.processImage(img, True, self.verbose, self.heat_map) print(img) filename = utils.getFilename(img) #Reads IMs first_map = cv2.imread(config.maps_folder + filename + '_gge_map_0_1.png') second_map = cv2.imread(config.maps_folder + filename + '_gge_map_1_1.png') #first_map = self.resizeImage(first_map, 200) #second_map = self.resizeImage(second_map, 200) if first_map is None or second_map is None: continue gge_b, gge_g, gge_r = cv2.split(first_map) iic_b, iic_g, iic_r = cv2.split(second_map) #Get maps dimensions rows, cols, _ = first_map.shape #Building heat map heat_map = np.sqrt( pow( gge_b[0:rows - 1, 0:cols - 1] - iic_b[0:rows - 1, 0:cols - 1], 2) + pow( gge_g[0:rows - 1, 0:cols - 1] - iic_g[0:rows - 1, 0:cols - 1], 2) + pow( gge_r[0:rows - 1, 0:cols - 1] - iic_r[0:rows - 1, 0:cols - 1], 2)) #Recover heat map max value max_value = np.ndarray.max(heat_map) #Normalization heat_map = heat_map / max_value sum = np.sum(heat_map) if self.heat_map: heat_map = heat_map * 255 heat_map = heat_map.astype(np.uint8) #Display color map color_map = cv2.applyColorMap(heat_map, cv2.COLORMAP_JET) cv2.imshow('img', utils.resizeImage(color_map, 500)) cv2.waitKey(0) print(sum)
def PlayFolder(folder): videos = utils.parseFolder(folder, subfolders=False) realVideos = [] for video in videos: video = video[1] if utils.isFilePlayable(video): if utils.getExtension(video) == SRC: playlist = utils.getPlaylistFromLocalSrc(video) for video in playlist: realVideos.append(video) else: realVideos.append(video) if len(realVideos) == 0: utils.DialogOK(GETTEXT(30102)) return videos = {} for video in realVideos: filename = utils.getFilename(video) if filename in videos: #prefer local duplicates over Amazon if 'AMAZON@' in videos[filename]: videos[filename] = video else: pass else: videos[filename] = video isFirst = True repeatMode = GetRepeatMode() for video in videos: video = videos[video] title, image = utils.GetTitleAndImage(video) AddToPlaylist(title, image, video, LOCAL_FILE+10000, isFirst) isFirst = False xbmc.executebuiltin('PlayerControl(%s)' % repeatMode)
def train(self, images, labels, direction='vertical'): for i in range(len(images)): featureFile = open('trained_features' + direction + '.txt', 'a') img = images[i] label = labels[i] self.filename = utils.getFilename(img) print('Processing ' + self.filename) # Reads image image = cv2.imread(img) rows, cols, _ = image.shape maskImage = np.zeros((rows, cols)) try: if direction == 'vertical': maskBand = np.ones((rows, label[2])) * 255 maskImage[:, label[0]:label[1]] = maskBand elif direction == 'horizontal': maskBand = np.ones((label[2], cols)) * 255 maskImage[label[0]:label[1], :] = maskBand except: print("Error evaluating band " + img) continue global_references = self.extractGlobalReferences(img) self.evaluateIlluminantMaps(image, maskImage, direction) # Evaluate distances medians = {} for i in range(self.verticalBands): filename = config.temp_folder + 'vertical_band_' + str( i) + "_gge_map_" for alg in self.algorithms: medians[alg] = utils.evaluateRGBMedian(filename + alg + ".png") band_feature = [] #Feature vector evaluated on medians band_feature_global = [ ] #Feature vector evaluated on the global references band = self.bands['vertical'][i] for alg in self.algorithms: distance = utils.euclideanDistanceRGB( medians[alg], self.verticalReferences[alg]) band_feature.append(distance) distance = utils.euclideanDistanceRGB( medians[alg], global_references[alg]) band_feature_global.append(distance) print('\tEvaluated ' + str(i + 1) + '/' + str(self.verticalBands) + ' vertical bands') featureFile.write(str(band.label) + ": ") for feat in band_feature: featureFile.write(str(feat) + " ") featureFile.write(":") for feat in band_feature_global: featureFile.write(str(feat) + " ") featureFile.write(":" + str(band.colorAvg)) featureFile.write("\n") for i in range(self.horizontalBands): filename = config.temp_folder + 'horizontal_band_' + str( i) + "_gge_map_" for alg in self.algorithms: medians[alg] = utils.evaluateRGBMedian(filename + alg + ".png") band = self.bands['horizontal'][i] band_feature = [] #Feature vector evaluated medians band_feaure_global = [ ] #Feature vector evaluated on the global references for alg in self.algorithms: distance = utils.euclideanDistanceRGB( medians[alg], self.horizontalReferences[alg]) band_feature.append(distance) distance = utils.euclideanDistanceRGB( medians[alg], global_references[alg]) band_feaure_global.append(distance) print('\tEvaluated ' + str(i + 1) + '/' + str(self.horizontalBands) + ' horizontal bands') featureFile.write(str(band.label) + ": ") for feat in band_feature: featureFile.write(str(feat) + " ") featureFile.write(":") for feat in band_feaure_global: featureFile.write(str(feat) + " ") featureFile.write(":" + str(band.colorAvg)) featureFile.write("\n") featureFile.close()
def estimateSecondGrayEdge(img, segmentedImg, outputFolder, verbose): filename = utils.getFilename(img) output = outputFolder + filename + "_gge_map_secondgrayedge.png" extractGGEMap(img, segmentedImg, 1, 2, 1, verbose, output=output)
def estimateShadesOfGray(img, segmentedImg, outputFolder, verbose): filename = utils.getFilename(img) output = outputFolder + filename + "_gge_map_shadesofgray.png" extractGGEMap(img, segmentedImg, 1, 0, 5, verbose, output=output)
def estimateMaxRGB(img, segmentedImg, outputFolder, verbose): filename = utils.getFilename(img) output = outputFolder + filename + "_gge_map_maxrgb.png" extractGGEMap(img, segmentedImg, 1, 0, 20, verbose, output=output)
def estimateGrayWorld(img, segmentedImg, outputFolder, verbose): filename = utils.getFilename(img) output = outputFolder + filename + "_gge_map_grayworld.png" extractGGEMap(img, segmentedImg, 1, 0, 1, verbose, output=output)
def load(name=None): if name is None: name = config.dataset images = [] labels = [] if name == 'DSO-1' or name == 'DSI-1': print('Loading ' + name + ' dataset') #Retrieving file list files = os.listdir(config.imagesFolder) for i in files: filename = utils.getFilename(i) try: img = config.imagesFolder + i if os.path.isfile(img) and not i.startswith('.'): images.append(img) #Retrieving label labelFile = open(config.labelsFolder + filename + '.txt', 'r') imageLabels = [ re.split(r'\t+', s.strip()) for s in labelFile.readlines() ] labelFile.close() labels.append(imageLabels) except: print("Error on processing image: " + i) print('Loaded ' + name + ' dataset') if name == 'COLORCHECKER': print('Loading color checked dataset') files = os.listdir(config.imagesFolder) for i in files: try: img = config.imagesFolder + i if os.path.isfile(img) and not i.startswith('.'): images.append(img) labels.append(1) except: print("Error on processing image: " + i) print('Loaded color checker dataset') if name == 'SPLICED_COLORCHECKER' or name == 'SPLICED_DSO1': print('Loading spliced color checked dataset') files = os.listdir(config.imagesFolder) for i in files: filename = utils.getFilename(i) try: img = config.imagesFolder + i _, file_extension = os.path.splitext(img) if os.path.isfile(img) and not i.startswith( '.') and file_extension == '.png': images.append(img) label = np.loadtxt(config.imagesFolder + filename + '.txt').tolist() labels.append(label) print('added ' + str(img)) except: print("Error on processing image: " + i) print('Loaded splicing color checker dataset') return images, labels
solution = [ solve(case, sheeps[case]) for case in range(0, number_of_cases) ] return solution def solve(case, sheeps): N = int(sheeps[0]) digits = set() i = 1 while len(digits) < 10: M = N * i digitsArr = getDigits(M) for digit in digitsArr: digits.add(digit) i += 1 if N == 0: return "Case #" + str(case + 1) + ": INSOMNIA" return "Case #" + str(case + 1) + ": " + str(M) def getDigits(N): Ns = [int(d) for d in str(N)] return Ns filename = utils.getFilename() input = utils.read_input(filename) output = process(input) utils.print_output(filename, output)
def train(self, images, labels): # Extract image features from each images in training set if self.extract_features or self.extract_maps: for i in range(len(images)): #Extract the faces in the image faces, _ = self.extractFaces(images[i], labels[i]) if len(faces) > 1: #If there are two or more faces, process the image filename = utils.getFilename(images[i]) print('Processing ' + filename) #Extract maps if self.extract_maps: self.extractIlluminationMaps(images[i]) #Extract face paired features if self.extract_features: # Extract image descriptors and features for illum in config.illuminantTypes: for desc in self.descriptors: self.extractFeatures(images[i], labels[i], faces=faces, illum=illum, descriptor=desc) else: #else discard the current image print('Not suitable number of faces found in the image') # Sample training if not self.cross_validation: # Train one model for each descriptor for illum in config.illuminantTypes: for desc in self.descriptors: trainingData, trainingLabels, _ = self.getTrainingData( images, desc, illum=illum) if len(trainingData) > 0: # Creates an instance of Neighbours Classifier and fit the data. clf = KNNClassifier(config.KNeighbours, 'uniform') clf.train(trainingData, trainingLabels) clf.store(config.classification_folder + 'model_' + illum + '_' + desc.lower() + '.pkl') print(illum + "/" + desc.upper() + ' classification model created correctly') else: #Crossvalidate dataset witk K-fold crossvalidation print('Evaluate dataset with crossvalidation') trainingDesc = {} for illum in config.illuminantTypes: for desc in self.descriptors: key = illum + "_" + desc trainingDesc[key] = self.getTrainingData(images, desc, illum=illum) #Counting misclassified samples for accuracy score misclassified = 0 refKey = config.illuminantTypes[0] + "_" + self.descriptors[0] #Splits dataset in train and test for crossvalidation splits = splitDataset(trainingDesc[refKey][0], config.folds) outputs_labels = trainingDesc[refKey][1] outputs_scores = np.zeros(len(trainingDesc[refKey][0])) for (trainIndex, testIndex) in splits: classifiers = {} for illum in config.illuminantTypes: for desc in self.descriptors: key = illum + "_" + desc trainingData, trainingLabels, _ = trainingDesc[key] if len(trainingData) > 0 and len(trainingLabels) > 0: trainingData = trainingData[trainIndex] trainingLabels = trainingLabels[trainIndex] #Training model for illum type and descriptor clf = KNNClassifier(config.KNeighbours, 'uniform') clf.train(trainingData, trainingLabels) classifiers[key] = clf outputs = [] outputs_probs = [] for illum in config.illuminantTypes: for desc in self.descriptors: key = illum + "_" + desc testData, _, _ = trainingDesc[key] if len(testData) > 0: testData = testData[testIndex] prediction = classifiers[key].predict( testData) * config.descriptors_weights[desc] outputs.append(prediction) prediction = classifiers[key].predict( testData, True) * config.descriptors_weights[desc] outputs_probs.append(prediction) output = np.zeros(len(testIndex)) output_prob = np.zeros(len(testIndex)) for i in range(len(outputs)): predictions = outputs[i] output += predictions predictions_prob = outputs_probs[i] for j in range(len(predictions)): output_prob[j] += predictions_prob[j][1] #If voting is majority, classify as fake outputs_scores[testIndex] = output_prob counter = 0 _, trainingLabels, _ = trainingDesc[refKey] testLabels = trainingLabels[testIndex] totalModels = len(classifiers) for val in np.nditer(output): if val > totalModels / 2: if testLabels[counter] != 1: misclassified += 1 else: if testLabels[counter] != 0: misclassified += 1 counter += 1 scipy.io.savemat( 'classification_output.mat', dict(labels=outputs_labels, scores=outputs_scores)) print('Number of classifiers: ' + str(totalModels)) totalSamples = len(trainingDesc[refKey][0]) print('Misclassified: ' + str(misclassified) + '/' + str(totalSamples)) accuracy = (totalSamples - misclassified) / totalSamples print('Accuracy: ' + str(accuracy))
def testGGEMaps(): images, labels = loadDatasets.load() length = len(algs) if evaluate: for img in images: filename = utils.getFilename(img) print('Processing ' + filename) illuminantMaps.prepareImageIlluminants(img, config.seg_sigma, config.seg_k, config.seg_min_size, config.min_intensity, config.max_intensity, False) illuminantMaps.estimateGrayEdge(img, filename + "_segmented.png", verbose) illuminantMaps.estimateGrayWorld(img, filename + "_segmented.png", verbose) illuminantMaps.estimateMaxRGB(img, filename + "_segmented.png", verbose) illuminantMaps.estimateShadesOfGray(img, filename + "_segmented.png", verbose) illuminantMaps.estimateSecondGrayEdge(img, filename + "_segmented.png", verbose) distanceMap = np.zeros((length, length), dtype=np.float64) for i in range(length): first = cv2.imread(config.maps_folder + filename + "_gge_map_" + algs[i] + ".png") for j in range(i + 1, length): second = cv2.imread(config.maps_folder + filename + "_gge_map_" + algs[j] + ".png") dist = utils.evaluateEuclideanDistances( first, second, display) distanceMap[i, j], distanceMap[j, i] = dist, dist np.savetxt(config.maps_folder + filename + '.out', distanceMap) '''Plot histogram''' for i in range(length): for j in range(i + 1, length): normal_x = [] spliced_x = [] normal_y = [] spliced_y = [] for k in range(len(images)): filename = utils.getFilename(images[k]) label = 0 if filename.find("splicing") > -1: label = 1 distanceMap = np.loadtxt(config.maps_folder + filename + '.out') if label == 0: normal_x.append(k) normal_y.append(distanceMap[i, j]) else: spliced_x.append(k) spliced_y.append(distanceMap[i, j]) normal_x = np.asarray(normal_x) spliced_x = np.asarray(spliced_x) normal_y = np.asarray(normal_y) spliced_y = np.asarray(spliced_y) plt.scatter(normal_x, normal_y, color='blue') plt.scatter(spliced_x, spliced_y, color='red') plt.savefig(config.maps_folder + algs[i] + '_' + algs[j]) plt.close()
def detect(self, img, groundtruth=True): self.filename = utils.getFilename(img) print('Processing ' + self.filename) # Reads image image = cv2.imread(img) if image is None: print('Error processing ' + self.filename + ': image not found') return image = utils.resizeImage(image, 1200) # Mask if groundtruth: maskImage = cv2.imread( config.masks_folder + self.filename + '.png', cv2.IMREAD_GRAYSCALE) if maskImage is not None: maskImage = np.invert(maskImage) maskImage = utils.resizeImage(maskImage, 1200) else: maskImage = None if image is not None: self.evaluateIlluminantMaps(image, maskImage) rows, cols, _ = image.shape detectionMap = np.zeros((rows, cols)) global_references = self.extractGlobalReferences(img) # Evaluate distances medians = {} for i in range(self.verticalBands): filename = config.temp_folder + 'vertical_band_' + str( i) + "_gge_map_" for alg in self.algorithms: medians[alg] = utils.evaluateRGBMedian(filename + alg + ".png") band = self.bands['vertical'][i] band_feature = [] for alg in self.algorithms: if config.referenceColorType == 'median': distance = utils.euclideanDistanceRGB( medians[alg], self.verticalReferences[alg]) elif config.referenceColorType == 'global': distance = utils.euclideanDistanceRGB( medians[alg], global_references[alg]) band_feature.append(distance) if config.regionalTrainingType is None: detectionMap = band.incrementDetection( detectionMap, distance) if config.regionalTrainingType == 'svm': clf_type = 'vertical' if config.referenceColorType == 'global': clf_type += '_global' prediction = self.clf[clf_type].predict_proba( np.asarray(band_feature).reshape((1, -1))) detectionMap = band.incrementDetection( detectionMap, prediction[0][1]) print('\tEvaluated ' + str(i + 1) + '/' + str(self.verticalBands) + ' vertical bands') for i in range(self.horizontalBands): filename = config.temp_folder + 'horizontal_band_' + str( i) + "_gge_map_" for alg in self.algorithms: medians[alg] = utils.evaluateRGBMedian(filename + alg + ".png") band = self.bands['horizontal'][i] band_feature = [] for alg in self.algorithms: if config.referenceColorType == 'median': distance = utils.euclideanDistanceRGB( medians[alg], self.verticalReferences[alg]) elif config.referenceColorType == 'global': distance = utils.euclideanDistanceRGB( medians[alg], global_references[alg]) band_feature.append(distance) if config.regionalTrainingType is None: detectionMap = band.incrementDetection( detectionMap, distance) if config.regionalTrainingType == 'svm': clf_type = 'horizontal' if config.referenceColorType == 'global': clf_type += '_global' prediction = self.clf[clf_type].predict_proba( np.asarray(band_feature).reshape((1, -1))) detectionMap = band.incrementDetection( detectionMap, prediction[0][1]) print('\tEvaluated ' + str(i + 1) + '/' + str(self.horizontalBands) + ' horizontal bands') # Recover detection map max value splicedPercent = len( np.where(detectionMap > config.fakeThreshold) [0]) / detectionMap.size print('Spliced area (%): ' + str(splicedPercent)) if splicedPercent > config.splicedTolerance: print('Image is SPLICED - Score: ' + str(splicedPercent)) outputMask = detectionMap.copy() outputMask[outputMask < config.fakeThreshold] = 0 outputMask[outputMask >= config.fakeThreshold] = 1 max_value = np.ndarray.max(detectionMap) detectionMap = detectionMap / max_value detectionMap *= 255 if self.display_result: # Display color map color_map = detectionMap color_map = color_map.astype(np.uint8) color_map = cv2.applyColorMap(color_map, cv2.COLORMAP_JET) out = np.concatenate((utils.resizeImage( image, 500), utils.resizeImage(color_map, 500)), axis=1) cv2.imshow('output', out) cv2.waitKey(0) # Display spliced regions regionMask = np.zeros(image.shape, 'uint8') regionMask[..., 0] = outputMask.copy() regionMask[..., 1] = outputMask.copy() regionMask[..., 2] = outputMask.copy() splicedRegions = np.multiply(image, regionMask) out = np.concatenate((utils.resizeImage( image, 500), utils.resizeImage(splicedRegions, 500)), axis=1) cv2.imshow('output', out) cv2.waitKey(0) # Write output mask outputMask *= 255 cv2.imwrite(config.regionOutputDetectionImage, outputMask) else: print('Image is ORIGINAL - Score: ' + str(splicedPercent)) else: print('No image found: ' + img)
def extractFeatures(self, img, label=None, faces=[], descriptor="ACC", space=0, illum='GGE', output=False): filename = utils.getFilename(img) if illum == 'GGE': map_path = config.maps_folder + filename + '_' + illum.lower( ) + '_map_' + str(config.gge_n) + "_" + str(config.gge_p) + ".png" else: map_path = config.maps_folder + filename + '_' + illum.lower( ) + '_map.png' illuminantMap = cv2.imread(map_path) #Storing faces extracted from maps count = 0 for (x, y, w, h) in faces: face = illuminantMap[y:y + h, x:x + w] path = config.faces_folder + "face-" + illum.upper() + "-" + str( count) + ".png" cv2.imwrite(path, face) descriptors.extractDescriptor(path, descriptor, space) count += 1 #Image features features = [] first = 0 while first < len(faces) - 1: second = first + 1 firstFaceFeat = config.faces_folder + 'face-' + illum + '-' + str( first) + "-" + descriptor.lower() + "-desc.txt" while second < len(faces): secondFaceFeat = config.faces_folder + 'face-' + illum + '-' + str( second) + "-" + descriptor.lower() + "-desc.txt" #Concat the two feature vector facePairFeature = descriptors.buildFaceFeatureVector( firstFaceFeat, secondFaceFeat, descriptor) if config.inverseFacePosition: inverseFacePairFeature = descriptors.buildFaceFeatureVector( secondFaceFeat, firstFaceFeat, descriptor) pairLabel = None if label is not None and not isinstance(label, str): pairLabel = 0 if label[first][1] != config.positiveLabel or label[ second][1] != config.positiveLabel: pairLabel = 1 sample = FaceTrainingSample(facePairFeature, pairLabel, first, second, filename) features.append(sample) if config.inverseFacePosition: sample = FaceTrainingSample(inverseFacePairFeature, pairLabel, second, first) features.append(sample) second += 1 first += 1 if self.verbose: print('\tFeatures extracted with ' + descriptor + ' descriptor in ' + illum + ' map') if not output: #Storing image feaures in file nameFile = config.features_folder + filename + '_' + illum + "_" + descriptor.lower( ) + ".txt" files = open(nameFile, "w") for sample in features: files.write(str(sample)) files.close() else: return features
import sys from utils import getFilename, readFile filename = getFilename(sys.argv) output = readFile(filename, str) output = [list(o) for o in output] originalOutput = output[:] def getResult(output, printOutput=True): result = [] for o in output: result.append("".join(o)) if printOutput: print(result[-1]) result = "".join(result) return result ### PART 1 ### def adjOccupiedNum(output, row, col): check = [] for i in range(max(row - 1, 0), min(row + 2, len(output))): for j in range(max(col - 1, 0), min(col + 2, len(output[0]))): if not i == row or not j == col: check.append((i, j))
def detect(self, img, detected_faces=None): filename = utils.getFilename(img) config.maps_folder = config.temp_folder config.faces_folder = config.temp_folder config.descriptors_folder = config.temp_folder print('Processing ' + filename) image = cv2.imread(img) if image is None: print('ERROR processing ' + filename + ': image not found') return -1 #Check if image is colored try: _, _, channels = image.shape if channels < 3: raise Exception() except Exception as e: print( 'ERROR: image is grayscale. Illuminant maps analysis cannot be performed.' ) return -1 #Loads classifier # Extracting image features # Extract the faces in the image faces, _ = self.extractFaces(img, detected_faces) #Prediction map predictions = {} counters = {} for i in range(len(faces)): predictions[i], counters[i] = 0, 0 #Image is precessable if there are more than one image if len(faces) > 1: # If there are two or more faces, process the image # Extract maps self.extractIlluminationMaps(img) # Extract image descriptors and features for illum in config.illuminantTypes: for desc in self.descriptors: clfPath = config.classification_folder + 'model_' + illum + '_' + desc.lower( ) + '.pkl' if os.path.isfile(clfPath): clf = KNNClassifier.load(clfPath) features = self.extractFeatures(img, label=detected_faces, faces=faces, illum=illum, descriptor=desc, output=True) #Predict over sample for sample in features: prediction = clf.predict( np.array(sample.feature.split(), dtype=float).reshape((1, -1)), True)[0][1] predictions[sample.first] += prediction predictions[sample.second] += prediction counters[sample.first] += 1 counters[sample.second] += 1 #Majority voting threshold = config.majorityVotingThreshold score = 0 detected = False fakeFaces = [] for i in predictions: if score < predictions[i] / counters[i]: score = predictions[i] / counters[i] if predictions[i] / counters[i] > threshold: fakeFaces.append(i) print('\tFace ' + str(i + 1) + ' is FAKE. Score ' + str(score)) if not detected: detected = not detected else: print('\tFace ' + str(i + 1) + ' is NORMAL. Score ' + str(predictions[i] / counters[i])) if detected: print('Image is FAKE') else: print('Image is ORIGINAL') orig = cv2.imread(img, cv2.COLOR_BGR2GRAY) #Display spliced faces rows, cols, _ = orig.shape outputMask = np.zeros((rows, cols)) faceScores = orig.copy() idx = 0 font = cv2.FONT_HERSHEY_SIMPLEX for (x, y, w, h) in faces: face_score = predictions[idx] / counters[i] if idx not in fakeFaces: cv2.rectangle(faceScores, (x, y), (x + w, y + h), (0, 255, 0), 8) cv2.putText(faceScores, str("{:.3f}".format(face_score)), (x, y + h + 80), font, 1.8, (0, 255, 0), 3) else: cv2.rectangle(faceScores, (x, y), (x + w, y + h), (0, 0, 255), 8) cv2.putText(faceScores, str("{:.3f}".format(face_score)), (x, y + h + 80), font, 1.8, (0, 0, 255), 3) #Set score in detection map outputMask[y:y + h, x:x + w] = face_score idx += 1 faceScores = utils.resizeImage(faceScores, 1000) if self.display_result: cv2.imshow('output', faceScores) cv2.waitKey() regionMask = np.zeros(orig.shape) regionMask[..., 0] = outputMask.copy() regionMask[..., 1] = outputMask.copy() regionMask[..., 2] = outputMask.copy() # Write output mask outputMask *= 255 cv2.imwrite(config.faceOutputDetectionImage, outputMask) return score else: # discard the current image print('Not suitable number of faces found in the image') return -1