def load_data(path): print("[INFO] loading images...") data = [] labels = [] # grab the image paths and randomly shuffle them imagePaths = sorted(list(paths.list_images(path))) random.seed(42) random.shuffle(imagePaths) # loop over the input images for imagePath in imagePaths: # load the image, pre-process it, and store it in the data list image = cv2.imread(imagePath) image = cv2.resize(image, (norm_size, norm_size)) image = img_to_array(image) data.append(image) # extract the class label from the image path and update the # labels list label = int(imagePath.split(os.path.sep)[-2]) labels.append(label) # scale the raw pixel intensities to the range [0, 1] data = np.array(data, dtype="float") / 255.0 labels = np.array(labels) # convert the labels from integers to vectors labels = to_categorical(labels, num_classes=CLASS_NUM) return data,labels
def extract(): imagepaths = sorted(paths.list_images('training_data/')) labels = [] data = [] for imagepath in imagepaths: label = imagepath[imagepath.rfind('/') + 1:].split('-')[0] image = cv2.imread(imagepath) features = describe_haralick_stats(image) labels.append(label) data.append(features) datafile = "models/features.pkl" td_file = open(datafile, 'wb') pickle.dump(data, td_file) td_file.close() labelfile = "models/labels.pkl" ld_file = open(labelfile, 'wb') pickle.dump(labels, ld_file) ld_file.close() return
def get_training_images(training_dir): training_images = dict() for image_path in paths.list_images(training_dir): leaf_sort = image_path.split("/")[-2] if leaf_sort in training_images: training_images[leaf_sort].append(image_path) else: training_images[leaf_sort] = [image_path] return training_images
def process_dir(dataset_path, output): files = paths.list_images(dataset_path) # for fname in files: f = open(output, 'a+') total = 0 # f.write("{}\n".format(encodings.base64_encode_image(face))) total += 1 print("[INFO] wrote {} frames to file".format(total)) f.close()
def get_train_data(path,img_cols,img_rows,num_imgs=-1): print path i=1 x_img=[] y_labels=[] if num_imgs!="-1": for imagePath in paths.list_images(path): i+=1 print(imagePath,str(i)) img=cv2.imread(imagePath) imagePath=imagePath.split("/") y_labels.append(int(imagePath[1].replace("c","")))#once we split, lists are like this #[train,c0,img3012341.jpg] #we want only integers for CNN model res = cv2.resize(img, (img_cols, img_rows)) res=res.transpose(2,0,1)#Size is now 3x32x32 x_img.append(res) if i==num_imgs: return x_img,y_labels print i else: print("HOLAAA") for imagePath in paths.list_images(path): i+=1 print(imagePath,str(i)) img=cv2.imread(imagePath) imagePath=imagePath.split("/") y_labels.append(int(imagePath[1].replace("c","")))#once we split, lists are like this #[train,c0,img3012341.jpg] #we want only integers for CNN model res = cv2.resize(img, (img_cols, img_rows)) res=res.transpose(2,0,1)#Size is now 3x32x32 x_img.append(res) return x_img,y_labels
def create(path): images = list(list_images(path)) outfile = '/tmp/out.avi' fourcc = cv2.VideoWriter_fourcc(*'XVID') out = None fps = 3 print(len(images)) for img in sorted(images): image = cv2.imread(img) if out is None: h, w = image.shape[:2] print(h, w) out = cv2.VideoWriter(outfile, fourcc, fps, (w, h)) out.write(image)
def create_gif(inputPath, outputPath, delay, finalDelay, loop): # grab all image paths in the input directory imagePaths = sorted(list(paths.list_images(inputPath))) # remove the last image path in the list lastPath = imagePaths[-1] imagePaths = imagePaths[:-1] # construct the image magick 'convert' command that will be used # generate our output GIF, giving a larger delay to the final # frame (if so desired) cmd = "convert -delay {} {} -delay {} {} -loop {} {}".format( delay, " ".join(imagePaths), finalDelay, lastPath, loop, outputPath) os.system(cmd)
def read_repre(repre_path): # f = open(repre_path, 'r') # repres = dict() # for l in f: # elems = l.strip().split(' ') # repres[elems[0]] = cv2.imread(elems[1]) # f.close() # return repres files = paths.list_images(repre_path) repres = {} for f in files: name = f.split('/')[-1] name = name[:name.rfind('.')] img = cv2.imread(f) repres[name] = img return repres
def hyperparameters_tuning(img): scaleFactor_list = [1.05, 1.1, 1.2] minNeighbors_list = [5, 8, 11] minSize_list = [60, 80, 100] it = len(scaleFactor_list) * len(minNeighbors_list) * len(minSize_list) curr_it = 0 res_file = open('/home/tomas/Dropbox/Data/celeb_dataset/hyperparameters_tuning.txt' 'w') for sf in scaleFactor_list: for mn in minNeighbors_list: for ms in minSize_list: missed = 0 extra = 0 ok = 0 n_files = 0 curr_it += 1 files = paths.list_images(dataset_path) # for fname in tqdm(files): for fname in files: n_files += 1 image = cv2.imread(fname) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # gray = imutils.resize(gray, width=width) im_face, n_faces, bbox, = detect_face(gray, fname, scaleFactor=sf, minNeighbors=mn, minSize=ms, save_face=save_face) if n_faces == 0: missed += 1 elif n_faces > 1: extra += n_faces - 1 else: ok += 1 # print 'total # of images: ', n_files print 'it #%i/%i -----------------------------------------------' % (curr_it, it) print 'params: sf=%.2f, mn=%i, ms=%i' % (sf, mn, ms) print 'ok: %i/%i, missed: %i, extra: %i' % (ok, n_files, missed, extra) print '\n' res_file.write('it #%i/%i -----------------------------------------------' % (curr_it, it)) res_file.write('params: sf=%.2f, mn=%i, ms=%i' % (sf, mn, ms)) res_file.write('ok: %i/%i, missed: %i, extra: %i' % (ok, n_files, missed, extra)) res_file.write('\n')
def create_base64_files(dataset_path, base64_path, face_cascade): if not os.path.exists(base64_path): os.mkdir(base64_path) fd = FaceDetector(face_cascade) print("[INFO] Extracting faces from dataset...") files = paths.list_images(dataset_path) data_dict = {} for f in files: # name = f.split('/')[-2][:f.split('/')[-1].rfind('.')] # label = name[:name.rfind('_')] label = f.split('/')[-2] img = cv2.imread(f, 0) img = imutils.resize(img, width=500) # faceRects = fd.detect(img, scaleFactor=1.1, minNeighbors=9, minSize=(100, 100)) faceRects = fd.detect(img, scaleFactor=1.1, minNeighbors=9, minSize=(40, 40)) if len(faceRects) > 0: (x, y, w, h) = max(faceRects, key=lambda b: (b[2] * b[3])) face = img[y:y + h, x:x + w].copy(order="C") else: # cv2.imshow('No face detected', img) # cv2.waitKey(0) # raise ValueError('No face deteted.') continue if data_dict.has_key(label): data_dict[label].append(face) else: data_dict[label] = list((face,)) # for fname in files: for k, v in data_dict.items(): filename = k + '.txt' filepath = os.path.join(base64_path, filename) f = open(filepath, 'a+') total = 0 for face in v: f.write("{}\n".format(encodings.base64_encode_image(face))) total += 1 print("[INFO] wrote {} frames to file {}".format(total, filename)) f.close()
def detect_batch(dataset_path, save_face=False): scaleFactor = 1.1 minNeighbors = 8 minSize = 60 missed = 0 extra = 0 ok = 0 n_files = 0 files = paths.list_images(dataset_path) faces = [] names = [] # files = ['/home/tomas/Dropbox/Data/celeb_dataset/natalie_portman/natalie_portman_07.jpg', ] for fname in files: n_files += 1 image = cv2.imread(fname) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) im_face, n_faces, bbox = detect_face(gray, fname, scaleFactor=scaleFactor, minNeighbors=minNeighbors, minSize=minSize, save_face=save_face) if n_faces == 0: missed += 1 print 'missed:', fname.split('/')[-1] elif n_faces > 1: extra += n_faces - 1 print 'extra:', fname.split('/')[-1] else: ok += 1 # imgs.append(im_face) bbox = bbox[0] # bboxes.append(bbox) face = gray[bbox[1]:bbox[1] + bbox[3], bbox[0]:bbox[0] + bbox[2]] faces.append(face) name = fname.split('/')[-1].split('.')[0] names.append(name) # print 'total # of images: ', n_files print 'ok: %i/%i, missed: %i, extra: %i' % (ok, n_files, missed, extra) return faces, names
def load_images(if_grayscale=False, if_normalize_images=IF_NORMALIZE_IMAGES): print('Loading image data...') images = [] image_labels = [] # For every class, for every image in its images dataset, accumulate into list of features & labels for (i, clazz) in enumerate(CLASSES): image_paths = list(paths.list_images(clazz.get('image_dir_path'))) image_paths = image_paths[0:IMAGE_COUNT_PER_CLASS] if IMAGE_COUNT_PER_CLASS else image_paths for image_path in image_paths: image = cv2.imread( image_path, cv2.IMREAD_GRAYSCALE if if_grayscale else cv2.IMREAD_COLOR, ) if if_normalize_images: image = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX) images.append(image) image_labels.append(i) return (images, image_labels)
def extract(conf): # grab the set of ground-truth images and select a percentage of them for training trnPaths = list(paths.list_images(conf["pos_raw_ph"])) assert len(trnPaths)!=0 # if not os.path.isdir(conf['pos_feat_ph']): os.makedirs(conf['pos_feat_ph']) # setup the progress bar widgets = ["Extracting: ", progressbar.Percentage(), " ", progressbar.Bar(), " ", progressbar.ETA()] pbar = progressbar.ProgressBar(maxval=len(trnPaths), widgets=widgets).start() for (i, imgPath) in enumerate(trnPaths): # img = imread(imgPath) # resize to the training resolution (wid,height) img = auto_resized(imread(imgPath, as_grey=True),conf['sliding_size']) fd=hog(img, conf['orientations'], conf['pixels_per_cell'], conf['cells_per_block'], conf['visualize'], conf['normalize']) fd_name = os.path.split(imgPath)[1].split(".")[0] + ".feat" fd_path = os.path.join(conf['pos_feat_ph'], fd_name) joblib.dump(fd, fd_path) pbar.update(i) pbar.finish() print '[*] Finished Pos.'
def data2files(data_dir, face_cascade, res_file_path, label_dict_path): # initializing face detector fd = FaceDetector(face_cascade) dataset = [] files = paths.list_images(data_dir) file_dict = process_files(files) for key in file_dict.keys(): print 'Processing %s ...' % key, celeb_files = file_dict[key] n_files = len(celeb_files) ok = 0 for f in celeb_files: item = create_data_item(f, fd) if item is not None: dataset.append(item) ok += 1 print 'done, face found: %i/%i (%i%%)' % (ok, n_files, int(100 * ok / n_files)) print 'Saving data in pickle format...', # data_fname = os.path.join(res_dir, 'data.npz') data_file = gzip.open(res_file_path, 'wb', compresslevel=1) pickle.dump(dataset, data_file) # np.save(data_file, np.array(data_cubes_resh)) data_file.close() print 'done' print 'Saving label dictionary ...' label_dict = {} names = file_dict.keys() for i, n in enumerate(names): label_dict[n] = i labels_file = gzip.open(label_dict_path, 'wb', compresslevel=1) pickle.dump(label_dict, labels_file) labels_file.close() print 'done'
ap.add_argument("-d", "--dataset", required=True, help="path to input dataset") #ap.add_argument("-a", "--augment", type=int, default=-1, # help="whether or not 'on the fly' data augmentation should be used") ap.add_argument("-p", "--plot", type=str, default="plot.png", help="path to output loss/accuracy plot") args = vars(ap.parse_args()) # # Using Resnet50 and initialised with weights of imagenet # ## images in smear 2005 are resized to 224 x224 # grab the list of images in our dataset directory, then initialize # the list of data (i.e., images) and class images print("[INFO] loading images...") imagePaths = list(paths.list_images(args["dataset"])) data = [] labels = [] # loop over the image paths for imagePath in imagePaths: # extract the class label from the filename, load the image, and # resize it to be a fixed 64x64 pixels, ignoring aspect ratio label = imagePath.split(os.path.sep)[-2] image = cv2.imread(imagePath, 1) image = cv2.resize(image, (224, 224)) # update the data and labels lists, respectively data.append(image) labels.append(label)
"--images", required=True, help="path to input directory of images") ap.add_argument( "-t", "--threshold", type=float, default=100.0, help="focus measures that fall below this value will be considered 'blurry'" ) args = vars(ap.parse_args()) outputfolder_path = "/content/drive/MyDrive/checking-blur/sharpimages/" i = 0 # loop over the input images for imagePath in paths.list_images(args["images"]): # load the image, convert it to grayscale, and compute the # focus measure of the image using the Variance of Laplacian # method name = path.splitext(os.path.basename(imagePath))[0] image = cv2.imread(imagePath) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) fm = variance_of_laplacian(gray) text = "Not Blurry" # if the focus measure is less than the supplied threshold, # then the image should be considered "blurry" if fm < args["threshold"]: text = "Blurry" # show the image cv2.putText(image, "{}: {:.2f}".format(text, fm), (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 0, 255), 3)
# USAGE # python build_dogs_vs_cats.py from config import dogs_and_cats_config as config from sklearn.preprocessing import LabelEncoder from sklearn.model_selection import train_test_split from pyimagesearch.preprocessing import AspectAwarePreprocessor from pyimagesearch.io import HDF5DatasetWriter from imutils import paths import numpy as np import progressbar import json import cv2 import os # grab the paths to the images train_paths = list(paths.list_images(config.IMAGES_PATH)) train_labels = [p.split(os.path.sep)[-1].split('.')[0] for p in train_paths] le = LabelEncoder() train_labels = le.fit_transform(train_labels) # perform stratified sampling from the training set to build the testing split from the training data train_paths, test_paths, train_labels, test_labels = train_test_split( train_paths, train_labels, test_size=config.NUM_TEST_IMAGES, stratify=train_labels, random_state=42) train_paths, val_paths, train_labels, val_labels = train_test_split( train_paths, train_labels, test_size=config.NUM_VAL_IMAGES,
TARGET_IMAGE_WIDTH = 28 TARGET_IMAGE_HEIGHT = 28 LR = 0.001 # 学习率 BATCH_SIZE = 64 EPOCHS = 40 ################################################ # 第一部分:数据预处理 # initialize the image preprocessor and datasetloader sp = SimplePreprocessor(TARGET_IMAGE_WIDTH, TARGET_IMAGE_HEIGHT) sdl = SimpleDatasetLoader(preprocessors=[sp]) # Load images print("[INFO] 导入图像...") image_paths = list(paths.list_images(dataset_path)) # path includedd print(paths.list_images(dataset_path)) (X, y) = sdl.load(image_paths, verbose=500, grayscale=True) # Flatten (reshape the data matrix) # convert from (13164,TARGET_IMAGE_WIDTH,TARGET_IMAGE_HEIGHT) #into (13164,TARGET_IMAGE_WIDTH*TARGET_IMAGE_HEIGHT) X = X.reshape((X.shape[0], TARGET_IMAGE_WIDTH * TARGET_IMAGE_HEIGHT)) X = X.astype("float") / 255.0 # 特征缩放,是非常重要的步骤 # Show some information on memory consumption of the images print("[INFO] features matrix: {:.1f}MB".format(X.nbytes / (1024 * 1024.0))) # Label encoder le = LabelEncoder() y = to_categorical(le.fit_transform(y), 2)
from tensorflow.keras.models import load_model import config from imutils import paths import numpy as np import imutils import random import cv2 import os # load the trained model from disk print("[INFO] loading model...") model = load_model(config.MODEL_PATH) # grab the paths to the fire and non-fire images, respectively print("[INFO] predicting...") firePaths = list(paths.list_images(config.FIRE_PATH)) nonFirePaths = list(paths.list_images(config.NON_FIRE_PATH)) # combine the two image path lists, randomly shuffle them, and sample # them imagePaths = firePaths + nonFirePaths random.shuffle(imagePaths) imagePaths = imagePaths[:config.SAMPLE_SIZE] # loop over the sampled image paths for (i, imagePath) in enumerate(imagePaths): # load the image and clone it image = cv2.imread(imagePath) output = image.copy() # resize the input image to be a fixed 128x128 pixels, ignoring
def predictImages(modelArg, labelsArg, imagePathArg, num_classesArg, min_confidenceArg, image_displayArg, pred_stagesArg): # initialize the model model = tf.Graph() # create a context manager that makes this model the default one for # execution with model.as_default(): # initialize the graph definition graphDef = tf.GraphDef() # load the graph from disk with tf.gfile.GFile(modelArg, "rb") as f: serializedGraph = f.read() graphDef.ParseFromString(serializedGraph) tf.import_graph_def(graphDef, name="") # load the class labels from disk labelMap = label_map_util.load_labelmap(labelsArg) categories = label_map_util.convert_label_map_to_categories( labelMap, max_num_classes=num_classesArg, use_display_name=True) categoryIdx = label_map_util.create_category_index(categories) # create a plateFinder plateFinder = PlateFinder(min_confidenceArg, categoryIdx, rejectPlates=False, charIOUMax=0.3) # create plate displayer plateDisplay = PlateDisplay() # create a session to perform inference with model.as_default(): with tf.Session(graph=model) as sess: # create a predicter, used to predict plates and chars predicter = Predicter(model, sess, categoryIdx) imagePaths = paths.list_images(imagePathArg) frameCnt = 0 start_time = time.time() platesReturn = [] numPlates = 0 # Loop over all the images for imagePath in imagePaths: frameCnt += 1 # load the image from disk print("[INFO] Loading image \"{}\"".format(imagePath)) image = cv2.imread(imagePath) (H, W) = image.shape[:2] # If prediction stages == 2, then perform prediction on full image, find the plates, crop the plates from the image, # and then perform prediction on the plate images if pred_stagesArg == 2: # Perform inference on the full image, and then select only the plate boxes boxes, scores, labels = predicter.predictPlates( image, preprocess=True) licensePlateFound_pred, plateBoxes_pred, plateScores_pred = plateFinder.findPlatesOnly( boxes, scores, labels) # loop over the plate boxes, find the chars inside the plate boxes, # and then scrub the chars with 'processPlates', resulting in a list of final plateBoxes, char texts, char boxes, char scores and complete plate scores plates = [] for plateBox in plateBoxes_pred: boxes, scores, labels = predicter.predictChars( image, plateBox) chars = plateFinder.findCharsOnly( boxes, scores, labels, plateBox, image.shape[0], image.shape[1]) if len(chars) > 0: plates.append(chars) else: plates.append(None) plateBoxes_pred, charTexts_pred, charBoxes_pred, charScores_pred, plateAverageScores_pred = plateFinder.processPlates( plates, plateBoxes_pred, plateScores_pred) # If prediction stages == 1, then predict the plates and characters in one pass elif pred_stagesArg == 1: # Perform inference on the full image, and then find the plate text associated with each plate boxes, scores, labels = predicter.predictPlates( image, preprocess=False) licensePlateFound_pred, plateBoxes_pred, charTexts_pred, charBoxes_pred, charScores_pred, plateScores_pred = plateFinder.findPlates( boxes, scores, labels) else: print( "[ERROR] --pred_stages {}. The number of prediction stages must be either 1 or 2" .format(pred_stagesArg)) quit() # Print plate text for charText in charTexts_pred: print(" Found: ", charText) # Display the full image with predicted plates and chars if image_displayArg == True: imageLabelled = plateDisplay.labelImage( image, plateBoxes_pred, charBoxes_pred, charTexts_pred) cv2.imshow("Labelled Image", imageLabelled) cv2.waitKey(0) imageResults = [] for i, plateBox in enumerate(plateBoxes_pred): imageResults.append({ 'plateText': charTexts_pred[i], 'plateBoxLoc': list(plateBox), 'charBoxLocs': list([list(x) for x in charBoxes_pred[i]]) }) numPlates += 1 platesReturn.append({ 'imagePath': imagePath.split("/")[-1], 'imageResults': imageResults }) # print some performance statistics curTime = time.time() processingTime = curTime - start_time fps = frameCnt / processingTime print( "[INFO] Processed {} frames in {:.2f} seconds. Frame rate: {:.2f} Hz" .format(frameCnt, processingTime, fps)) #results = results.encode('utf-8') return { "processingTime": processingTime, "numPlates": numPlates, "numImages": len(platesReturn), "images": platesReturn }
def train_network(num_epochs=30, LETTER_IMAGES_FOLDER="images"): """ Trains a convolutional neural network to our training set and outputs the model to a local file to be read and used """ MODEL_FILENAME = "model.hdf5" MODEL_LABELS_FILENAME = "model_labels.dat" # initialize the data and labels data = [] labels = [] # loop over the input images for image_file in paths.list_images(LETTER_IMAGES_FOLDER): # Load the image and convert it to grayscale image = cv2.imread(image_file, 0) if image is None: # the filename was probably too long print( "WARNING: We couldn't open this image, its filename is probably too long:" ) print(image_file) continue # threshold _, image = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU) image = crop_letter(image) # Resize the letter so it fits in a 20x20 pixel box image = resize_to_fit(image, 20, 20) # Add a third channel dimension to the image to make Keras happy image = np.expand_dims(image, axis=2) # Grab the name of the letter based on the folder it was in label = image_file.split(os.path.sep)[-1].replace('.png', '') # Add the letter image and it's label to our training data data.append(image) labels.append(label) # scale the raw pixel intensities to the range [0, 1] (this improves training) data = np.array(data, dtype="float") / 255.0 labels = np.array(labels) # Split the training data into separate train and test sets (X_train, X_test, Y_train, Y_test) = train_test_split(data, labels, test_size=0.25, random_state=0) # Convert the labels (letters) into one-hot encodings that Keras can work with lb = LabelBinarizer().fit(Y_train) Y_train = lb.transform(Y_train) Y_test = lb.transform(Y_test) # Save the mapping from labels to one-hot encodings. # We'll need this later when we use the model to decode what it's predictions mean with open(MODEL_LABELS_FILENAME, "wb") as f: pickle.dump(lb, f) # Build the neural network! model = Sequential() # First convolutional layer with max pooling model.add( Conv2D(20, (5, 5), padding="same", input_shape=(20, 20, 1), activation="relu")) model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2))) # Second convolutional layer with max pooling model.add(Conv2D(50, (5, 5), padding="same", activation="relu")) model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2))) # Hidden layer with 500 nodes model.add(Flatten()) model.add(Dense(500, activation="relu")) # Output layer with 70 nodes (one for each possible letter/number we predict) model.add(Dense(97, activation="softmax")) # Ask Keras to build the TensorFlow model behind the scenes model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"]) # Train the neural network model.fit(X_train, Y_train, validation_data=(X_test, Y_test), batch_size=32, epochs=num_epochs, verbose=1) # Save the trained model to disk model.save(MODEL_FILENAME)
args = vars(ap.parse_args()) model = SeparableConv.build_model(width=48, height=48, depth=3, classes=2) opt = Adagrad(lr=config.INIT_LR, decay=config.INIT_LR / config.NUM_EPOCHS) model.compile(loss="binary_crossentropy", optimizer=opt, metrics=["accuracy"]) print(model.summary()) from keras.utils import plot_model plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True) # determine the total number of image paths in training, validation, # and testing directories trainPaths = list(paths.list_images(config.TRAIN_PATH))[:5000] totalTrain = len(trainPaths) totalVal = len(list(paths.list_images(config.VAL_PATH))) totalTest = len(list(paths.list_images(config.TEST_PATH))) print("totalTrain : % 2d, totalVal : % 2d, totalTest: % 2d" % (totalTrain, totalVal, totalTest)) # account for skew in the labeled data trainLabels = [int(p.split(os.path.sep)[-2]) for p in trainPaths] trainLabels = np_utils.to_categorical(trainLabels) classTotals = trainLabels.sum(axis=0) classWeight = classTotals.max() / classTotals # initialize the training training data augmentation object trainAug = ImageDataGenerator(rescale=1 / 255.0,
# USAGE run in cmd: python3 encode_faces.py or python encode_faces.py # import the necessary packages from imutils import paths import face_recognition import pickle import cv2 import os # construct the argument parser and parse the arguments # grab the paths to the input images in our dataset print("[INFO] quantifying faces...") imagePaths = list(paths.list_images("dataset")) # initialize the list of known encodings and known names knownEncodings = [] knownNames = [] # loop over the image paths for (i, imagePath) in enumerate(imagePaths): # extract the person name from the image path print("[INFO] processing image {}/{}".format(i + 1, len(imagePaths))) name = imagePath.split(os.path.sep)[-2] print(name) # load the input image and convert it from RGB (OpenCV ordering) # to dlib ordering (RGB) image = cv2.imread(imagePath) rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
def empty_download_folder(): imagePaths = list(paths.list_images(FTP_DIRECTORY)) for image in imagePaths: os.remove(image)
def ListarImagenesDirectorio(dir): return sorted(list(paths.list_images(dir + "/")))
# -*- coding: utf-8 -*- """ Created on Fri May 3 15:20:00 2018 @author: jercas """ from imutils import paths import pandas as pd import numpy as np from icecream.icecream import ic import shutil import os pathDirs = list(paths.list_images("./dataset/train_origin")) data = np.loadtxt("train.txt", dtype=np.str_, delimiter=' ') pathTxts = data[:, 0] pathLabel = data[:, 1] count = 1 for i, pathTxt in enumerate(pathTxts): for j, pathDir in enumerate(pathDirs): purePathDir = pathDir.split(os.path.sep)[-1] if pathTxt == purePathDir: ic(pathDir) ic(pathTxt) label = pathLabel[i] if not os.path.exists("./dataset/train_split/{}".format(label)): os.mkdir("./dataset/train_split/{}".format(label)) shutil.copyfile( pathDir, "./dataset/train_split/{}/{}".format(label, pathTxt)) ic(count)
p = os.path.sep.join([args["output"], "{}.jpg".format( str(total).zfill(8))]) f = open(p, "wb") f.write(r.content) f.close() # update the counter print("[INFO] downloaded: {}".format(p)) total += 1 # handle if any exceptions are thrown during the download process except: print("[INFO] error downloading {}...skipping".format(p)) # loop over the image paths we just downloaded for imagePath in paths.list_images(args["output"]): # initialize if the image should be deleted or not delete = False # try to load the image try: image = cv2.imread(imagePath) # if the image is `None` then we could not properly load it # from disk, so delete it if image is None: delete = True # if OpenCV cannot load the image then the image is likely # corrupt so we should delete it except:
# initialize the HOG descriptor/person detector hog = cv2.HOGDescriptor() hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector()) #video capture vidcap = cv2.VideoCapture(r'C:\ADITYA\Computervision\UCF50_videos\UCF50\BaseballPitch\v_BaseballPitch_g01_c01.avi') success,image = vidcap.read() count = 0 while success: cv2.imwrite(r"C:\ADITYA\Computervision\UCF50_videos\BaseballPitch_frames\frame%d.jpg" % count, image) # save frame as JPEG file success,image = vidcap.read() print('Read a new frame: ', success) count += 1 # loop over the image paths imagePaths = list(paths.list_images(args["images"])) d=0 for imagePath in imagePaths: # load the image and resize it to (1) reduce detection time # and (2) improve detection accuracy image = cv2.imread(imagePath) image = imutils.resize(image, width=min(400, image.shape[1])) orig = image.copy() # detect people in the image (rects, weights) = hog.detectMultiScale(image, winStride=(4, 4), padding=(8, 8), scale=1.05) # draw the original bounding boxes for (x, y, w, h) in rects:
def prepare_cifar_data_for_ae2_svdd(train_path, test_path, modelpath): NB_IV3_LAYERS_TO_FREEZE = 4 side = 32 side = 32 channel = 3 ## Declare the scoring functions g = lambda x: 1 / (1 + tf.exp(-x)) # g = lambda x : x # Linear def nnScore(X, w, V, g): # print "X",X.shape # print "w",w[0].shape # print "v",V[0].shape return tf.matmul(g((tf.matmul(X, w))), V) def relu(x): y = x y[y < 0] = 0 return y def add_new_last_layer(base_model_output, base_model_input): """Add last layer to the convnet Args: base_model: keras model excluding top nb_classes: # of classes Returns: new keras model with last layer """ x = base_model_output print("base_model.output", x.shape) inp = base_model_input print("base_model.input", inp.shape) dense1 = Dense(128, name="dense_output1")(x) # new sigmoid layer dense1out = Activation("relu", name="output_activation1")(dense1) dense2 = Dense(1, name="dense_output2")(dense1out) # new sigmoid layer dense2out = Activation("relu", name="output_activation2")( dense2) # new sigmoid layer model = Model(inputs=inp, outputs=dense2out) return model # load the trained convolutional neural network freeze all the weights except for last four layers print("[INFO] loading network...") model = load_model(modelpath) model = add_new_last_layer(model.output, model.input) print(model.summary()) print("Length of model layers...", len(model.layers)) # Freeze the weights of untill the last four layers for layer in model.layers[:NB_IV3_LAYERS_TO_FREEZE]: layer.trainable = False for layer in model.layers[NB_IV3_LAYERS_TO_FREEZE:]: layer.trainable = True print("[INFO] loading images for training...") data = [] data_test = [] labels = [] labels_test = [] # grab the image paths and randomly shuffle them imagePaths = sorted(list(paths.list_images(train_path))) # loop over the input training images image_dict = {} test_image_dict = {} i = 0 for imagePath in imagePaths: # load the image, pre-process it, and store it in the data list image = cv2.imread(imagePath) image = cv2.resize(image, (side, side)) image = img_to_array(image) data.append(image) image_dict.update({i: imagePath}) i = i + 1 # extract the class label from the image path and update the # labels list label = imagePath.split(os.path.sep)[-2] label = 1 if label == "dogs" else 0 labels.append(label) # scale the raw pixel intensities to the range [0, 1] data = np.array(data) y = keras.utils.to_categorical(labels, num_classes=2) # print image_dict print("[INFO] preparing test data (anomalous )...") testimagePaths = sorted(list(paths.list_images(test_path))) # loop over the test images j = 0 for imagePath in testimagePaths: # load the image, pre-process it, and store it in the data list image = cv2.imread(imagePath) image = cv2.resize(image, (side, side)) image = img_to_array(image) data_test.append(image) test_image_dict.update({j: imagePath}) j = j + 1 # extract the class label from the image path and update the # labels list label = imagePath.split(os.path.sep)[-2] label = 0 if label == "cats" else 1 labels_test.append(label) # scale the raw pixel intensities to the range [0, 1] data_test = np.array(data_test) ## Normalise the data data = np.array(data) / 255.0 data_test = np.array(data_test) / 255.0 # Preprocess the inputs x_train = data x_test = data_test ## Obtain the intermediate output layer_name = 'dense_1' intermediate_layer_model = Model( inputs=model.input, outputs=model.get_layer(layer_name).output) layer1 = model.get_layer("dense_output1") layer2 = model.get_layer("dense_output2") intermediate_output = intermediate_layer_model.predict(x_train) X = intermediate_output intermediate_output = intermediate_layer_model.predict(x_test) X_test = intermediate_output K.clear_session() return [X, X_test]
hist = hist.astype("float") hist /= (hist.sum() + eps) # return the histogram of Local Binary Patterns return hist #%% # initialize the local binary patterns descriptor along with # the data and label lists desc = LocalBinaryPatterns(24, 8) data = [] labels = [] #%% # loop over the training images for imagePath in paths.list_images('/home/alfredo/Desktop/PROJECTS/Master Thesis/opencv/images/local_binary_patterns/training'): # load the image, convert it to grayscale, and describe it image = cv2.imread(imagePath) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) hist = desc.describe(gray) # extract the label from the image path, then update the # label and data lists labels.append(imagePath.split(os.path.sep)[-2]) data.append(hist) #%% # train a Linear SVM on the data model = LinearSVC(C=100.0, random_state=42) model.fit(data, labels)
ap.add_argument("-p", "--plot", type=str, default="plot.png", help="path to output loss/accuracy plot") args = vars(ap.parse_args()) EPOCHS = 25 INIT_LR = 1e-3 BS = 32 print("[INFO] loading images...") data = [] labels = [] imagePaths = sorted(list(paths.list_images(args["dataset"]))) random.seed(42) random.shuffle(imagePaths) for imagePath in imagePaths: image = cv2.imread(imagePath) image = cv2.resize(image, (28, 28)) image = img_to_array(image) data.append(image) label = imagePath.split(os.path.sep)[-2] label = 1 if label == "fire" else 0 labels.append(label) data = np.array(data, dtype="float") / 255.0 labels = np.array(labels)
import imutils import cv2 import random import pickle # Construct the argument parser and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-m", "--model", required=True, help="path to trained model") ap.add_argument("-t", "--testset", required=True, help="path to test images") args = vars(ap.parse_args()) # Resize parmeters (RESIZE should be the same as used in training) RESIZE = 96 # Grab the image paths and randomly shuffle them image_paths = sorted(list(paths.list_images(args["testset"]))) random.seed() random.shuffle(image_paths) # Read labels for classes to recognize mlb = pickle.loads(open(args["model"] + ".lbl", "rb").read()) labels = mlb.classes_ # Load the trained network model = load_model(args["model"] + ".h5") print(model.summary()) for image_path in image_paths: # Load the image image = cv2.imread(image_path) output = imutils.resize(image, width=400)
from imutils import paths # Config crop_start = (50, 285) crop_size = (224, 224) dark_factor = 0.3 # Prepare crop area crop_area = numpy.index_exp[ crop_start[0]:crop_start[0]+crop_size[0], crop_start[1]:crop_start[1]+crop_size[1] ] # find the image paths and randomly shuffle them print("# loading images...") imagePaths = sorted(list(paths.list_images(sys.argv[1], contains="capture"))) print("# loaded %d images." % (len(imagePaths))) for imagePath in imagePaths: image = cv2.imread(imagePath) orig = image[crop_area] image = (image * dark_factor).astype(numpy.uint8) image[crop_area] = orig cv2.imshow("Output", image) key_raw = cv2.waitKey(0) try: key = chr(key_raw) if key in ['d', 'D']: print("delete:%s" % imagePath) os.unlink(imagePath) elif key in ['p', 'P', 'y', 'Y']:
from keras.layers.core import Flatten, Dense from helpers import resize_to_fit from keras.callbacks import ModelCheckpoint, TensorBoard from keras.utils.vis_utils import plot_model # LETTER_IMAGES_FOLDER = "extracted_letter_images" LETTER_IMAGES_FOLDER = "extracted_letter_images" MODEL_FILENAME = "captcha_model.hdf5" MODEL_LABELS_FILENAME = "model_labels.dat" # initialize the data and labels data = [] labels = [] # loop over the input images for image_file in paths.list_images(LETTER_IMAGES_FOLDER): # Load the image and convert it to grayscale image = cv2.imread(image_file) try: image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) except Exception: print(image) # Resize the letter so it fits in a 20x20 pixel box image = resize_to_fit(image, 20, 20) # Add a third channel dimension to the image to make Keras happy image = np.expand_dims(image, axis=2) # Grab the name of the letter based on the folder it was in label = image_file.split(os.path.sep)[-2]
def train(number_neighbors, focus, hidden_layer_sizes, max_iter_bpnn, max_iter_svm): respond = {} __init_log(focus) respond['focus'] = focus imagePaths = list(paths.list_images(FOLDER_DATASET)) rawImages = [] features = [] labels = [] for (i, imagePath) in enumerate(imagePaths): image = cv2.imread(imagePath) label = imagePath.split(os.path.sep)[-1].split(".")[0] pixels = __image_to_feature_vector(image) hist = __extract_color_histogram(image) rawImages.append(pixels) features.append(hist) labels.append(label) if i > 0 and ((i + 1) % 200 == 0 or i == len(imagePaths) - 1): size_images = len(imagePaths) line = "[INFO] processed {}/{}".format(i + 1, size_images) respond['length_images'] = size_images __write_log(line) labels = np.array(labels) if focus == 'histogram': features = np.array(features) size_package = '{:.2f}MB'.format(features.nbytes / (1024 * 1000.0)) line = '[INFO] features matrix: ' + size_package respond['size_package'] = size_package __write_log(line) (trainFeat, testFeat, trainLabels, testLabels) = train_test_split(features, labels, test_size=0.15, random_state=42) # k-NN line = "[INFO] evaluating histogram accuracy..." __write_log(line) model = KNeighborsClassifier(n_neighbors=number_neighbors) model.fit(trainFeat, trainLabels) acc = model.score(testFeat, testLabels) line = "[INFO] k-NN classifier: k=%d" % number_neighbors __write_log(line) accuracy_knn = '{:.2f}%'.format(acc * 100) line = "[INFO] histogram accuracy: " + accuracy_knn respond['accuracy_knn'] = accuracy_knn __write_log(line) joblib.dump(model, FILE_MODELS_HISTOGRAM_KNN) # neural network line = "[INFO] evaluating histogram accuracy..." __write_log(line) model = MLPClassifier(hidden_layer_sizes=(50, ), max_iter=1000, alpha=1e-4, solver='sgd', tol=1e-4, random_state=1, learning_rate_init=.1) model.fit(trainFeat, trainLabels) acc = model.score(testFeat, testLabels) accuracy_bpnn = "{:.2f}%".format(acc * 100) line = "[INFO] neural network histogram accuracy: " + accuracy_bpnn respond['accuracy_bpnn'] = accuracy_bpnn __write_log(line) joblib.dump(model, FILE_MODELS_HISTOGRAM_BPNN) # SVC line = "[INFO] evaluating histogram accuracy..." __write_log(line) model = SVC(max_iter=1000, class_weight='balanced') model.fit(trainFeat, trainLabels) acc = model.score(testFeat, testLabels) accuracy_svm = '{:.2f}%'.format(acc * 100) line = "[INFO] SVM-SVC histogram accuracy: " + accuracy_svm respond['accuracy_svm'] = accuracy_svm __write_log(line) joblib.dump(model, FILE_MODELS_HISTOGRAM_SVM) respond['success'] = True return respond elif focus == 'pixel': rawImages = np.array(rawImages) size_package = "{:.2f}MB".format(rawImages.nbytes / (1024 * 1000.0)) line = "[INFO] pixels matrix: " + size_package respond['size_package'] = size_package __write_log(line) (trainRI, testRI, trainRL, testRL) = train_test_split(rawImages, labels, test_size=0.15, random_state=42) # k-NN line = "[INFO] evaluating raw pixel accuracy..." __write_log(line) model = KNeighborsClassifier(n_neighbors=number_neighbors) model.fit(trainRI, trainRL) acc = model.score(testRI, testRL) line = "[INFO] k-NN classifier: k=%d" % number_neighbors __write_log(line) accuracy_knn = "{:.2f}%".format(acc * 100) line = "[INFO] raw pixel accuracy: " + accuracy_knn respond['accuracy_knn'] = accuracy_knn __write_log(line) joblib.dump(model, FILE_MODELS_PIXEL_KNN) # neural network line = "[INFO] evaluating raw pixel accuracy..." __write_log(line) model = MLPClassifier(hidden_layer_sizes=(hidden_layer_sizes, ), max_iter=max_iter_bpnn, alpha=1e-4, solver='sgd', tol=1e-4, random_state=1, learning_rate_init=.1) model.fit(trainRI, trainRL) acc = model.score(testRI, testRL) accuracy_bpnn = "{:.2f}%".format(acc * 100) line = "[INFO] neural network raw pixel accuracy: " + accuracy_bpnn respond['accuracy_bpnn'] = accuracy_bpnn __write_log(line) joblib.dump(model, FILE_MODELS_PIXEL_BPNN) # SVC line = "[INFO] evaluating raw pixel accuracy..." __write_log(line) model = SVC(max_iter=max_iter_svm, class_weight='balanced') model.fit(trainRI, trainRL) acc = model.score(testRI, testRL) accuracy_svm = "{:.2f}%".format(acc * 100) line = "[INFO] SVM-SVC raw pixel accuracy: " + accuracy_svm respond['accuracy_svm'] = accuracy_svm __write_log(line) joblib.dump(model, FILE_MODELS_PIXEL_SVM) respond['success'] = True return respond else: respond['success'] = False respond['error'] = 'focus no esperado' return respond
# -*- coding: utf-8 -*- """ Created on Thu Jul 9 04:16:07 2020 @author: Devdarshan """ import os from imutils import paths path = "Fire/" path2 = "images/" imagePaths = list(paths.list_images(path)) import cv2 i = 0 for imagePath in imagePaths: # load the image and resize it to be a fixed 128x128 pixels, # ignoring aspect ratio print(imagePath) image = cv2.imread(imagePath) image = cv2.resize(image, (608, 608)) cv2.imwrite(os.path.join(path2, "{}.jpg").format(i), image) i += 1
f_ishift = numpy.fft.ifftshift(fshift) img_fft = numpy.fft.ifft2(f_ishift) img_fft = 20*numpy.log(numpy.abs(img_fft)) result = numpy.mean(img_fft) return result # construct the argument parse and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-i", "--images", required=True, help="path to input directory of images") args = vars(ap.parse_args()) # loop over the input images for i, imagePath in enumerate(sorted(paths.list_images(args["images"]))): # load the image, convert it to grayscale, and compute the # focus measure of the image using the Variance of Laplacian # method image = cv2.imread(imagePath) image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY) eqhist = cv2.equalizeHist(gray) metrics = {} width, height, _ = image.shape cropped = image[50:height-50,50:width-50,:] grayc = cv2.cvtColor(cropped, cv2.COLOR_RGB2GRAY)
# import the necessary packages from imutils import paths import argparse import dlib import cv2 # construct the argument parse and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-d", "--detector", required=True, help="Path to trained object detector") ap.add_argument("-t", "--testing", required=True, help="Path to directory of testing images") args = vars(ap.parse_args()) # load the detector detector = dlib.simple_object_detector(args["detector"]) # loop over the testing images for testingPath in paths.list_images(args["testing"]): # load the image and make predictions image = cv2.imread(testingPath) boxes = detector(cv2.cvtColor(image, cv2.COLOR_BGR2RGB)) # loop over the bounding boxes and draw them for b in boxes: (x, y, w, h) = (b.left(), b.top(), b.right(), b.bottom()) cv2.rectangle(image, (x, y), (w, h), (0, 255, 0), 2) print (x,y) # show the image cv2.imshow("Image", image) cv2.waitKey(0)
import cv2 import numpy as np from imutils import paths import os from sklearn.metrics import accuracy_score from matplotlib import pyplot as plt classes = {1: 'Bike', 2: 'Horse'} labels = [] dictionarySize = 12 BOW = cv2.BOWKMeansTrainer(dictionarySize) sift = cv2.xfeatures2d.SIFT_create() imagePaths = list(paths.list_images("train")) for image in imagePaths: label = image.split('/')[1] if label == 'Bike': labels.append(1) elif label == 'Horse': labels.append(2) image = image.replace("\\","") img = cv2.imread(image,0) kp, des = sift.detectAndCompute(img,None) BOW.add(des) dictionary = BOW.cluster() print("Created Bag of Words")
ap.add_argument("-l", "--labelbin", required=True, help="path to output label binarizer") ap.add_argument("-p", "--plot", type=str, default="plot.png", help="path to output accuracy/loss plot") args = vars(ap.parse_args()) # initialize the number of epochs to train for, initial learning rate, # batch size, and image dimensions EPOCHS = 75 INIT_LR = 1e-3 BS = 32 IMAGE_DIMS = (96, 96, 3) # grab the image paths and randomly shuffle them print("[INFO] loading images...") imagePaths = sorted(list(paths.list_images(args["dataset"]))) random.seed(42) random.shuffle(imagePaths) # initialize the data and labels data = [] labels = [] # loop over the input images for imagePath in imagePaths: # load the image, pre-process it, and store it in the data list image = cv2.imread(imagePath) image = cv2.resize(image, (IMAGE_DIMS[1], IMAGE_DIMS[0])) image = img_to_array(image) data.append(image)
help="Path to the CALTECH-101 class annotations") ap.add_argument("-o", "--output", required=True, help="Path to the output detector") args = vars(ap.parse_args()) # grab the default training options for our HOG + Linear SVM detector initialize the # list of images and bounding boxes used to train the classifier print("[INFO] gathering images and bounding boxes...") options = dlib.simple_object_detector_training_options() images = [] boxes = [] # loop over the image paths for imagePath in paths.list_images(args["class"]): # extract the image ID from the image path and load the annotations file imageID = imagePath[imagePath.rfind("/") + 1:].split("_")[1] imageID = imageID.replace(".jpg", "") p = "{}/annotation_{}.mat".format(args["annotations"], imageID) annotations = loadmat(p)["box_coord"] # loop over the annotations and add each annotation to the list of bounding # boxes bb = [ dlib.rectangle(left=long(x), top=long(y), right=long(w), bottom=long(h)) for (y, h, x, w) in annotations ] boxes.append(bb)
import numpy as np import argparse import imutils import cv2 # construct the argument parse and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-i", "--images", required=True, help="path to images directory") args = vars(ap.parse_args()) # initialize the HOG descriptor/person detector hog = cv2.HOGDescriptor() hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector()) # loop over the image paths for imagePath in paths.list_images(args["images"]): # load the image and resize it to (1) reduce detection time # and (2) improve detection accuracy image = cv2.imread(imagePath) image = imutils.resize(image, width=min(400, image.shape[1])) orig = image.copy() # detect people in the image (rects, weights) = hog.detectMultiScale(image, winStride=(4, 4), padding=(8, 8), scale=1.05) # draw the original bounding boxes for (x, y, w, h) in rects: cv2.rectangle(orig, (x, y), (x + w, y + h), (0, 0, 255), 2) # apply non-maxima suppression to the bounding boxes using a
ap = argparse.ArgumentParser() ap.add_argument("-b", "--base-model", required=True, help="base model path") ap.add_argument("-i", "--images", required=True, help="base path to input directory of images") ap.add_argument("-o", "--output", required=True, help="base path to output directory") ap.add_argument("-l", "--layers", nargs='+', default=["conv2/3x3", "inception_3b/5x5_reduce", "inception_4c/output"], help="layer or layers to use") args = ap.parse_args() # buy the ticket, take the ride bc = BatCountry(args.base_model) # loop over the input directory of images for imagePath in paths.list_images(args.images): # loop over the layers for layer in args.layers: # we can't stop here... print("[INFO] processing `{}`".format(imagePath)) image = bc.dream(np.float32(Image.open(imagePath)), end=layer) # write the output image to file filename = imagePath[imagePath.rfind("/") + 1:] outputPath = "{}/{}_{}".format(args.output, layer.replace("/", "_"), filename) result = Image.fromarray(np.uint8(image)) result.save(outputPath) # do some cleanup bc.cleanup()
import cv2 ap = argparse.ArgumentParser() ap.add_argument("-d", "--dataset", required=True) ap.add_argument("-k", "--clusters", type=int, default=2, help="# of clusters to generate") args = vars(ap.parse_args()) # initialize the image descriptor along with the image matrix desc = LabHistogram([8, 8, 8]) data = [] # grab image paths from dataset directory image_paths = list(paths.list_images(args["dataset"])) image_paths = np.array(sorted(image_paths)) # loop over the input dataset of images for im_path in image_paths: # load the image, describe the image, then update the list of data image = cv2.imread(im_path) hist = desc.describe(image) data.append(hist) # cluster the color histograms clt = KMeans(n_clusters=args["clusters"]) labels = clt.fit_predict(data) from IPython import embed
def move(path): for pf in list_images(path): f = pf.split('/')[-1] new_f = f[0] + ("%05d" % int(f[1:-4])) + f[-4:] shutil.move(pf, os.path.join(path, new_f))
# Freeze the weights of untill the last four layers for layer in model.layers[:NB_IV3_LAYERS_TO_FREEZE]: layer.trainable = False for layer in model.layers[NB_IV3_LAYERS_TO_FREEZE:]: layer.trainable = True # declare the global variable print("[INFO] loading images for training...") data = [] data_test = [] labels = [] labels_test = [] # grab the image paths and randomly shuffle them imagePaths = sorted(list(paths.list_images(train_path))) import random random.seed(42) random.shuffle(imagePaths) # loop over the input training images image_dict = {} i = 0 for imagePath in imagePaths: # load the image, pre-process it, and store it in the data list image = cv2.imread(imagePath) image = cv2.resize(image, (28, 28)) image = img_to_array(image) data.append(image) image_dict.update({i: imagePath}) i = i + 1
img_rows, img_cols = 28, 28 # number of convolutional filters to use nb_filters = 32 # size of pooling area for max pooling pool_size = (2, 2) # convolution kernel size kernel_size = (3, 3) # the data, shuffled and split between train and test sets # (X_train, y_train), (X_test, y_test) = mnist.load_data() X_train = np.empty((0, 1, img_rows, img_cols)) y_train = np.empty((0)) X_test = np.empty((0, 1, img_rows, img_cols)) y_test = np.empty((0)) for i in range(0, 10): (X, Y) = build_batch(sorted(list(paths.list_images("dataset/{}".format(i)))), img_rows, img_cols) X_train = np.concatenate((np.asarray(X[0:75]), X_train)) y_train = np.concatenate((np.asarray(Y[0:75]), y_train)) X_test = np.concatenate((np.asarray(X[75:]), X_test)) y_test = np.concatenate((np.asarray(Y[75:]), y_test)) print(X_train.shape) print(y_train.shape) print(X_test.shape) print(y_test.shape) if K.image_dim_ordering() == 'th': X_train = X_train.reshape(X_train.shape[0], 1, img_rows, img_cols) X_test = X_test.reshape(X_test.shape[0], 1, img_rows, img_cols) input_shape = (1, img_rows, img_cols) else:
from localbinarypatterns import LocalBinaryPatterns from imutils import paths import cv2 import pandas as pd import numpy as np from skimage import feature import matplotlib.pyplot as plt db = 'yale' data_training = 'db/%s' % db P = 8 # número de pontos R = 8 # raio dataset = [file for file in paths.list_images(data_training)] desc = LocalBinaryPatterns(8, 8) gbr = paths.list_images(data_training) nama_gbr = gbr.__next__() print(nama_gbr) image = cv2.imread(nama_gbr) gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) lbp = feature.local_binary_pattern(gray, P, R, method='uniform') hist = np.histogram(lbp.ravel(), bins=range(0, P + 3)) h = hist[0].astype('float') h /= (h.sum()) print(h, h.sum()) plt.bar(np.array(range(0, P + 2)), h) plt.xticks(np.array(range(0, P + 2))) plt.ylabel('Percentage') plt.show()
if self.preprocessors is not None: for p in self.preprocessors: image = p.preprocess(image) #print(image.shape) data.append(image) labels.append(label) if verbose > 0 and i>0 and (i+1)%verbose==0: print("[INFO] processed {}/{}".format(i+1, len(imagePaths))) return(np.array(data), np.array(labels)) # In[57]: image_paths = list(paths.list_images('/home/padmach/data/DogVsCats/train')) # In[58]: sp = SimplePreprocessor(32, 32) sdl = SimpleDatasetLoader(preprocessors=[sp]) (data, labels) = sdl.load(image_paths, verbose=500) # In[60]: data = data.reshape((data.shape[0], 3072)) # In[63]:
from imutils import paths import numpy as np import imutils import cv2 crop = 1 print("[INFO] loading images...") imagePaths = sorted(list(paths.list_images('images'))) print(imagePaths) images = [] for imagePath in imagePaths: image = cv2.imread(imagePath) images.append(image) print("[INFO] stitching images...") stitcher = cv2.createStitcher() if imutils.is_cv3() else cv2.Stitcher_create() (status, stitched) = stitcher.stitch(images) if status == 0: if crop > 0: print("[INFO] cropping...") stitched = cv2.copyMakeBorder(stitched, 10, 10, 10, 10, cv2.BORDER_CONSTANT, (0, 0, 0)) gray = cv2.cvtColor(stitched, cv2.COLOR_BGR2GRAY) thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY)[1]
f = open(p, "wb") f.write(r.content) f.close() # update the counter print("[INFO] downloaded: {}".format(p)) total += 1 # handle if any exceptions are thrown during the download process except: print("[INFO] error downloading {}...skipping".format(p)) # loop over the image paths we just downloaded for imagePath in paths.list_images(args["output"]): # initialize if the image should be deleted or not delete = False # try to load the image try: image = cv2.imread(imagePath) # if the image is `None` then we could not properly load it # from disk, so delete it if image is None: delete = True # if OpenCV cannot load the image then the image is likely # corrupt so we should delete it except:
cv2.namedWindow("quadro") cv2.setMouseCallback("quadro",alteraEstado,param=(lista,img)) cv2.imshow("quadro",img) print conta,'Arq:',lista[conta]["filename"],' Sel Status:',lista[conta]["isok"] if __name__ == '__main__': cascade = cv2.CascadeClassifier(args.cascade) largeimg = np.zeros((800,1280,3),np.uint8) xpos = 0 ypos = 0 listaInfoJ = [] conta = 0 for pimagem in paths.list_images(mypath): print pimagem rgbIn = cv2.imread(pimagem) [heb,wib,pb] = rgbIn.shape rects,bdisp=detect(rgbIn, cascade) for x1, y1, x2, y2 in rects: x1,y1,x2,y2 = RepUtil.novoEquad(x1,y1,x2,y2,wib,heb) vis_roi = rgbIn[y1:y2, x1:x2] [he,wi,pro] = vis_roi.shape if wi > 640: fato = 640.0/float(wi) rgbFrame = cv2.resize(vis_roi,(0,0),fx=fato,fy=fato) else: rgbFrame = vis_roi.copy() bb = align.getLargestFaceBoundingBox(rgbFrame) bbs = [bb] if bb is not None else []
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) print("[INFO] Model Compiled!") return model #%% print("[INFO] loading images from private data...") data = [] labels = [] # grab the image paths and randomly shuffle them imagePaths = sorted( list(paths.list_images('C:\\Users\\User\\spn_myone\\spn_pr')) ) # data folder with 2 categorical folders random.seed(SEED) random.shuffle(imagePaths) # loop over the input images for imagePath in imagePaths: # load the image, resize the image to be 32x32 pixels (ignoring aspect ratio), # flatten the 32x32x3=3072 pixel image into a list, and store the image in the data list image = cv2.imread(imagePath) #image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) image = cv2.resize(image, (32, 32)) / 255 data.append(image) # extract the class label from the image path and update the labels list label = imagePath.split(os.path.sep)[-2]
print "{}".format(rect) x1,y1,x2,y2 = novoEquadR(rect,w,h) print "{}; {}; {}; {}".format(x1,y1,x2,y2) newim = img[y1:y2,x1:x2].copy() bb = align.getLargestFaceBoundingBox(newim) if bb is None: continue hr,wr,c = newim.shape if wr > 600: newim = cv2.resize(newim,(0,0),fx=0.5,fy=0.5) return newim return None if __name__ == '__main__': cascade = cv2.CascadeClassifier(join("..","..","data","haarcascades","haarcascade_frontalface_alt2.xml")) for pimagem in paths.list_images(pathimg): print pimagem im = cv2.imread(pimagem) if im is None: continue im=detect(im, cascade) if im is None: continue h,w,c = im.shape if h < 100 or w < 100: print "Imagem pequena??? -> {} -> {}x{}".format(pimagem,w,h) continue if im is None:
import numpy as np import argparse import imutils import cv2 # construct the argument parse and parse the arguments ap = argparse.ArgumentParser() ap.add_argument("-i", "--images", required=True, help="path to images directory") args = vars(ap.parse_args()) # initialize the HOG descriptor/person detector hog = cv2.HOGDescriptor() hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector()) # loop over the image paths imagePaths = list(paths.list_images(args["images"])) for imagePath in imagePaths: # load the image and resize it to (1) reduce detection time # and (2) improve detection accuracy image = cv2.imread(imagePath) image = imutils.resize(image, width=min(400, image.shape[1])) orig = image.copy() # detect people in the image (rects, weights) = hog.detectMultiScale(image, winStride=(4, 4), padding=(8, 8), scale=1.05) # draw the original bounding boxes for (x, y, w, h) in rects: cv2.rectangle(orig, (x, y), (x + w, y + h), (0, 0, 255), 2)
# author: Adrian Rosebrock # website: http://www.pyimagesearch.com # import the necessary packages from __future__ import print_function from imutils import paths # loop over the image paths in the previous 'demo_images' # directory and print the paths to the terminal for imagePath in paths.list_images("../demo_images"): print(imagePath)
MODEL_FILENAME = "captcha_model.hdf5" MODEL_LABELS_FILENAME = "model_labels.dat" CAPTCHA_IMAGE_FOLDER = "generated_captcha_images" # Load up the model labels (so we can translate model predictions to actual letters) with open(MODEL_LABELS_FILENAME, "rb") as f: lb = pickle.load(f) # Load the trained neural network model = load_model(MODEL_FILENAME) # Grab some random CAPTCHA images to test against. # In the real world, you'd replace this section with code to grab a real # CAPTCHA image from a live website. captcha_image_files = list(paths.list_images(CAPTCHA_IMAGE_FOLDER)) captcha_image_files = np.random.choice(captcha_image_files, size=(100,), replace=False) # loop over the image paths for image_file in captcha_image_files: # Load the image and convert it to grayscale image = cv2.imread(image_file) image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) # Add some extra padding around the image image = cv2.copyMakeBorder(image, 20, 20, 20, 20, cv2.BORDER_REPLICATE) # threshold the image (convert it to pure black and white) thresh = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1] # find the contours (continuous blobs of pixels) the image
def readImagesAndAnnotations(self): self.imagePaths = list(paths.list_images(self.inputPath))
import config from imutils import paths import random import shutil import os # Grab the paths to all input images in the original input directory and shuffle them imagePaths = list(paths.list_images(config.ORIG_INPUT_DATASET)) random.seed(100) random.shuffle(imagePaths) # Compute the training and testing split i = int(len(imagePaths) * config.TRAIN_SPLIT) trainPaths = imagePaths[:i] testPaths = imagePaths[i:] # Using part of the training dataa for validation val_num = int(len(trainPaths) * config.VAL_SPLIT) valPaths = trainPaths[:i] trainPaths = trainPaths[i:] # Define the datasets that we'll be building datasets = [("training", trainPaths, config.TRAIN_PATH), ("validation", valPaths, config.VALIDATION_PATH), ("testing", testPaths, config.TEST_PATH)] # Loop over the datasets for (dataType, imagePaths, baseOutput) in datasets: # Show which dataset we are creating print("[INFO] Buildint {} split.".format(dataType))
def updata(identity,path,base,oldFname,separator="\\"): listIm = paths.list_images(path) contai = 0 for fileim in listIm: vf = fileim.split(separator) #print vf[len(vf)-1] if oldFname is not None: if fileim in oldFname: print "O arquivo {} tem duplicacao".format(fileim) continue #print "Processa {}".format(fileim) img = cv2.imread(fileim) mdb.gravaIm(img, base, contai, identity,vf[len(vf)-1], ".png") contai += 1 return contai