How to use the imutils.paths.list_images function in imutils

To help you get started, we’ve selected a few imutils examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

github jercas / DL_CV / selfImplementation / SB / application / multi_labels_classification / train.py View on Github external
ap.add_argument("-p", "--plot", type=str, default="./output/plot.png", help="path to output acc/loss curve.")
args = vars(ap.parse_args())

# Initialize the number of epochs to train for, initialize learning rate, batch size, and image dimensions.
EPOCHS = 75
INIT_LR = 1e-3          # The default value for the 'Adam' optimizer.
BATCH_SIZE = 32
IMAGE_DIMS = (96, 96, 3)

# Initialize the data and labels.
data = []
labels = []

# Grob the image paths and randomly shuffle them.
print("[INFO] loading image...")
imagePaths = sorted(list(paths.list_images(args["dataset"])))
random.seed(42)
random.shuffle(imagePaths)

# Loop over the input image.
for imagePath in imagePaths:
	# Load image, preprocess 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)

	# Extract set of class labels (each element is a 2-element list, e.g., ['red', 'dress']) from the image path and update the label list.
	label = imagePath.split(os.path.sep)[-2].split("_")
	labels.append(label)

# Scaling the raw pixel intensities to the range [0, 1].
github lonePatient / Deep_Learning_For_Computer_Vision_With_Python / chapter_10 / dogs_vs_cats / extract_features.py View on Github external
# 命令行参数
ap = argparse.ArgumentParser()
ap.add_argument('-d',"--dataset",required = True,
                help = 'path to input dataset')
ap.add_argument("-0",'--output',required = True,
                help = 'path ot output hdf5 file')
ap.add_argument('-b','--batch_size',type = int,default = 16,
                help='batch size of images to ba passed through network')
ap.add_argument('-s','--buffer_size',type=int,default=1000,
                help = 'size of feature extraction buffer')
args = vars(ap.parse_args())
# batch
bs = args['batch_size']

print("[INFO] loading images...")
imagePaths = list(paths.list_images(args['dataset']))
# 混洗数据
random.shuffle(imagePaths)
# 标签获取
labels = [p.split(os.path.sep)[-1].split(".")[0] for p in imagePaths]
# 编码编码化
le = LabelEncoder()
labels = le.fit_transform(labels)
print("[INFO] loading network...")
# imagenet上训练的权重
model = ResNet50(weights = 'imagenet',include_top=False)
#ResNet50的最后一个average pooling层的维度是2048
dataset = HDF.HDF5DatasetWriter((len(imagePaths),2048),
                            args['output'],dataKey='feature',buffSize=args['buffer_size'])
dataset.storeClassLabels(le.classes_)

# 初始化进度条
github Great1414 / traffic / process / data_input.py View on Github external
def load_data(path,norm_size,class_num):
    data = []#数据x
    label = []#标签y
    image_paths = sorted(list(paths.list_images(path)))#imutils模块中paths可以读取所有文件路径
    random.seed(0)#保证每次数据顺序一致
    random.shuffle(image_paths)#将所有的文件路径打乱
    for each_path in image_paths:
        image = cv2.imread(each_path)#读取文件
        image = cv2.resize(image,(norm_size,norm_size))#统一图片尺寸
        image = img_to_array(image)
        data.append(image)
        maker = int(each_path.split(os.path.sep)[-2])#切分文件目录,类别为文件夹整数变化,从0-61.如train文件下00014,label=14
        label.append(maker)
    data = np.array(data,dtype="float")/255.0#归一化
    label = np.array(label)
    label = to_categorical(label,num_classes=class_num)#one-hot
    return data,label
github dmr5bq / computer-vision-final / code / subtraction.py View on Github external
def find_background_image(class_name, path):
	"""Given a directory and a class name, search for a viable background image"""
	# This method based on: http://www.pyimagesearch.com/2015/11/09/pedestrian-detection-opencv/
	 
	# initialize the HOG descriptor/person detector
	hog = cv2.HOGDescriptor()
	hog.setSVMDetector(cv2.HOGDescriptor_getDefaultPeopleDetector())

	# loop over the image paths for each class
	class_path = os.path.join(path, class_name) 
	for imagePath in paths.list_images(class_path):
		# load the image and resize it to [faster, more accurate]
		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 bounding boxes
		for (x, y, w, h) in rects:
			cv2.rectangle(orig, (x, y), (x + w, y + h), (0, 0, 255), 2)

		# If there are no people (no boxes), return the path of this image
		if len(rects) == 0:
			return imagePath
github italia / cie-nis-python-sdk / OpenCV / detect_mrz.py View on Github external
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 a rectangular and square structuring kernel
rectKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (13, 5))
sqKernel = cv2.getStructuringElement(cv2.MORPH_RECT, (21, 21))

# loop over the input image paths
for imagePath in paths.list_images(args["images"]):
	# load the image, resize it, and convert it to grayscale
	print imagePath
	image = cv2.imread(imagePath)
	image = imutils.resize(image, height=600)
	gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
 
	# smooth the image using a 3x3 Gaussian, then apply the blackhat
	# morphological operator to find dark regions on a light background
	gray = cv2.GaussianBlur(gray, (3, 3), 0)
	blackhat = cv2.morphologyEx(gray, cv2.MORPH_BLACKHAT, rectKernel)

	# compute the Scharr gradient of the blackhat image and scale the
	# result into the range [0, 255]
	gradX = cv2.Sobel(blackhat, ddepth=cv2.CV_32F, dx=1, dy=0, ksize=-1)
	gradX = np.absolute(gradX)
	(minVal, maxVal) = (np.min(gradX), np.max(gradX))
github apollos / opencv-practice / local_binary_patterns / search_shirts.py View on Github external
import argparse
import cv2

# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-d", "--dataset", required=True, help="path to the dataset of shirt images")
ap.add_argument("-q", "--query", required=True, help="path to the query image")
args = vars(ap.parse_args())

# initialize the local binary patterns descriptor and initialize the index dictionary
# where the image filename is the key and the features are the value
desc = LocalBinaryPatterns(24, 8)
index = {}

# loop over the shirt images
for imagePath in paths.list_images(args["dataset"]):
	# 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)

	# update the index dictionary
	filename = imagePath[imagePath.rfind("/") + 1:]
	index[filename] = hist

# load the query image and extract Local Binary Patterns from it
query = cv2.imread(args["query"])
queryFeatures = desc.describe(cv2.cvtColor(query, cv2.COLOR_BGR2GRAY))

# show the query image and initialize the results dictionary
cv2.imshow("Query", query)
results = {}
github arunponnusamy / cvlib / cvlib / utils.py View on Github external
def animate(src, gif_name, reshape=None, fps=25):

    if not isinstance(src, list):

        if os.path.isdir(src):

            src = list(paths.list_images(src))

            for idx, image in enumerate(src):
                src[idx] = cv2.imread(image)

    if reshape:

        for idx, image in enumerate(src):
            src[idx] = cv2.resize(image, reshape)

    for idx, image in enumerate(src):
            src[idx] = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

    src = np.array(src)
    
    imageio.mimsave(gif_name, src, fps=fps)
github apollos / opencv-practice / first_try / train_simple.py View on Github external
# initialize characters string
alphabet = "abcdefghijklmnopqrstuvwxyz0123456789"

# initialize the data and labels for the alphabet and digits
alphabetData = []
digitsData = []
alphabetLabels = []
digitsLabels = []

# initialize the descriptor
print("[INFO] describing font examples...")
blockSizes = ((5, 5), (5, 10), (10, 5), (10, 10))
desc = BlockBinaryPixelSum(targetSize=(30, 15), blockSizes=blockSizes)

# loop over the font paths
for fontPath in paths.list_images(args["fonts"]):
	# load the font image, convert it to grayscale and threshold it
	font = cv2.imread(fontPath)
	font = cv2.cvtColor(font, cv2.COLOR_BGR2GRAY)
	thresh = cv2.threshold(font, 128, 255, cv2.THRESH_BINARY_INV)[1]

	# detect contours in the thresholded image and sort them from left to right
	(cnts, _) = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
	cnts = sorted(cnts, key=lambda c:(cv2.boundingRect(c)[0] + cv2.boundingRect(c)[1]))

	# loop over the contours
	for (i, c) in enumerate(cnts):
		# grab the bounding box for the contour, extract the ROI, and extract features
		(x, y, w, h) = cv2.boundingRect(c)
		roi = thresh[y:y + h, x:x + w]
		features = desc.describe(roi)
github smearle / gym-city / visualize.py View on Github external
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)

imutils

A series of convenience functions to make basic image processing functions such as translation, rotation, resizing, skeletonization, displaying Matplotlib images, sorting contours, detecting edges, and much more easier with OpenCV and both Python 2.7 and Python 3.

MIT
Latest version published 4 years ago

Package Health Score

64 / 100
Full package analysis