def detect(self, image, winDim, winStep=4, pyramidScale=1.5, minProb=0.7):
boxes = []
probs = []
# loop over the image pyramid (scale down image by pyramidScale)
for layer in helpers.pyramid(image, scale=pyramidScale,
minSize=winDim):
scale = image.shape[0] / float(layer.shape[0])
# loop over the sliding widnows for hte current pyramid lyaer
# 由左至右，以 sliding_window 的大小從目前的 pyramid layer 擷取影像內容
for (x, y,
window) in helpers.sliding_window(layer, winStep, winDim):
# Get window dimensions
(winH, winW) = window.shape[:2]
# ensure the window dimensions match the supplied sliding window dimensions
if winH == winDim[1] and winW == winDim[0]:
# Get the HOG features and reshape it to one raw array (features vector)
features = self.desc.describe(window).reshape(1, -1)
# use our trained model to predict by using this feature vector
prob = self.model.predict_proba(features)[0][1]
# if probability over the min threshold, then add it into the result array
if prob > minProb:
(startX, startY) = (int(scale * x), int(scale * y))
endX = int(startX + (scale * winW))
endY = int(startY + (scale * winH))
boxes.append((startX, startY, endX, endY))
probs.append(prob)
return (boxes, probs)
def slide(input_img, output):
pixelate_count = 0
for resized in helpers.pyramid(input_img, scale=2):
# loop over the sliding window for each layer of the pyramid
for (x, y, window) in helpers.sliding_window(resized, stepSize=STEP_SIZE, windowSize=(WIN_SIZE, WIN_SIZE)):
# if the window does not meet our desired window size, ignore it
if window.shape[0] != WIN_SIZE or window.shape[1] != WIN_SIZE:
continue
# This code below shows sliding window
# clone = resized.copy()
# cv2.rectangle(clone, (x, y), (x + WIN_SIZE, y + WIN_SIZE), (0, 255, 0), 2)
# Ensure crop is on the original location after pyramid resize
temp_y_start = y + (input_img.shape[1] - resized.shape[1])
temp_x_start = x + (input_img.shape[0] - resized.shape[0])
temp_y_end = temp_y_start + WIN_SIZE
temp_x_end = temp_x_start + WIN_SIZE
try:
crop_img = cv2.resize(resized[temp_y_start:temp_y_end, temp_x_start:temp_x_end], (200, 200))
except Exception as e:
continue
# Emoji confidence is below 0.9, above is nonsense
if emoji_AI(crop_img) < 0.9:
# If verified an emoji, pixelate
pixelate_count += 1
output[temp_y_start:temp_y_end, temp_x_start:temp_x_end] = \
pixelate(output[temp_y_start:temp_y_end, temp_x_start:temp_x_end])
print("Number of pixelation:", pixelate_count)
return output
def detect(self, image, winDim, winStep=4, pyramidScale=1.5, minProb=0.7):
boxes = []
probs = []
# loop over the image pyramid
for layer in helpers.pyramid(image, scale=pyramidScale,
minSize=winDim):
scale = image.shape[0] / float(layer.shape[0])
# loop over the sliding window
for (x, y,
window) in helpers.sliding_window(layer, winStep, winDim):
(winH, winW) = window.shape[:2]
# ensure the window is not truncated
# since sliding_window does not check boundaries
if winH == winDim[1] and winH == winDim[0]:
# extract HOG features from current window
# and classify if contains an object
features = self.desc.describe(window)
features = feature.hog(
window,
orientations=conf["orientations"],
pixels_per_cell=tuple(conf["pixels_per_cell"]),
cells_per_block=tuple(conf["cells_per_block"]),
transform_sqrt=conf["normalize"])
def scan_image(path):
# load the image and define the window width and height
image = cv2.imread(path, cv2.IMREAD_COLOR)
# loop over the image pyramid
level = 0
lst_img = list()
lst_imgDetail = list()
ori_clone = image.copy()
overlapImg = image.copy()
for resized_image in pyramid(image, scale):
# loop over the sliding window for each layer of the pyramid
for (x, y, window) in sliding_window(resized_image, stepSize=stepSize, windowSize=(winW, winH)):
# if the window does not meet our desired window size, ignore it
if window.shape[0] != winH or window.shape[1] != winW:
continue
# THIS IS WHERE YOU WOULD PROCESS YOUR WINDOW, SUCH AS APPLYING A
# MACHINE LEARNING CLASSIFIER TO CLASSIFY THE CONTENTS OF THE
# WINDOW
curWindow = (x, y, x + winW, y + winH)
subImage = utils.to_image(resized_image).crop(curWindow)
normalized_img = pre_processing_data.process_single_file(subImage)
lst_img.append(normalized_img)
imgDetail = (x, y, level, resized_image)
lst_imgDetail.append(imgDetail)
level += 1
# Predict all window
lst_indexPositive, positive_scores = predict_multi(lst_img, model_path)
time_now("fusing")
for i in lst_indexPositive:
subX, subY, subLevel, subImg = lst_imgDetail[i]
ori_x, ori_y, new_winW, new_winH = reverse_window(subX, subY, subImg.shape[1], subImg.shape[0],
scale ** subLevel, image.shape[1], image.shape[0], winW, winH)
# Get positive image and save it
ori_window = (ori_x, ori_y, ori_x + new_winW, ori_y + new_winH)
# Draw rectangle on output image
cv2.rectangle(ori_clone, (ori_x, ori_y), (ori_x + new_winW, ori_y + new_winH), (0, 255, 0), 2)
lstRect.append(ori_window)
overlappedLst = run_NMS(lstRect, positive_scores, 0.05)
time_now("draw rect")
for i in overlappedLst:
x1, y1, x2, y2 = lstRect[i]
cv2.rectangle(overlapImg, (x1, y1), (x2, y2), (0, 255, 0), 2)
result_path = os.path.join(stored_path, 'result.png')
not_overlap = os.path.join(stored_path, 'be4.png')
utils.to_image(ori_clone).save(not_overlap, 'png')
utils.to_image(overlapImg).save(result_path, 'png')
return result_path, len(overlappedLst)
def find_ppl(img):
for (counter,
resized) in enumerate(pyramid(img, scale=1.2, minSize=(128, 128)), 1):
###################################################################### y , x (h , w)
for (x, y, window) in sliding_window2(resized,
stepSize_h=32,
stepSize_v=16,
windowSize=(128, 64)):
############## y, h x, w
if window.shape[0] != 128 or window.shape[1] != 64:
continue
clone = resized.copy()
crop_img = clone[y:y + 128, x:x + 64]
lbp_hist = lbp2(crop_img, method='uniform')
#prediction = model.predict(lbp_hist.reshape(1, -1))
pred = model.decision_function(lbp_hist.reshape(1, -1))
#cv2.imshow('cropped', crop_img)
weight = 1.2**(counter - 1)
##################################### PRZEDSTAWIENIE GRAFICZNE SKANOWANIA
if pred > 0:
xw = int(x * weight)
yw = int(y * weight)
dx = int(64 * weight)
dy = int(128 * weight)
cv2.rectangle(clone, (x, y), (x + 64, y + 128), (0, 255, 0), 2)
#cv2.rectangle(img, (xw,yw), (xw+dx, yw+dy), (0,255,0), 2) ################ ZAZNACZENIE NA ORAZIE WYKRYTYCH SYLWETEK
rects.append((xw, yw, xw + dx, yw + dy, pred))
#cv2.imwrite('neg_mine_128x64\\neg_mine' + str(i) + '.png', crop_img)
#i += 1
else:
cv2.rectangle(clone, (x, y), (x + 64, y + 128), (0, 0, 255), 2)
cv2.imshow("window", clone)
if cv2.waitKey(1) == 0x1b:
break
#time.sleep(0.025)
#print(counter)
if cv2.waitKey(1) == 0x71:
break
#hm = heatmap(rects, img.shape[0], img.shape[1])
#print(len(rects))
#print(numpy.array(rects))
pick = non_max_suppression_moje2(numpy.array(rects), 0.6)
#print(pick)
# draw the final bounding boxes
for (xA, yA, xB, yB, c, vote) in pick:
print(vote)
print(0.15 * len(rects))
# cv2.waitKey(0)
if vote > 0.15 * len(rects):
cv2.rectangle(img, (int(xA), int(yA)), (int(xB), int(yB)),
(0, 255, 0), 2)
return img
def detect(self, image, winDim, winStep=4, pyramidScale=1.5, minProb=0.7):
# initialize the list of bounding boxes and associated probabilities
boxes = []
probs = []
# loop over the image pyramid
for layer in helpers.pyramid(image, scale=pyramidScale,
minSize=winDim):
# determine the current scale of the pyramid
scale = image.shape[0] / float(layer.shape[0])
# loop over the sliding windows for the current pyramid layer
for (x, y,
window) in helpers.sliding_window(layer, winStep, winDim):
# grab the dimensions of the window
(winH, winW) = window.shape[:2]
# ensure the window dimensions match the supplied sliding window dimensions
if winH == winDim[1] and winW == winDim[0]:
# extract HOG features from the current window and classifiy whether or
# not this window contains an object we are interested in
features = self.desc.describe(window).reshape(1, -1)
prob = self.model.predict_proba(features)[0][1]
# check to see if the classifier has found an object with sufficient
# probability
if prob > minProb:
# compute the (x, y)-coordinates of the bounding box using the current
# scale of the image pyramid
(startX, startY) = (int(scale * x), int(scale * y))
endX = int(startX + (scale * winW))
endY = int(startY + (scale * winH))
# update the list of bounding boxes and probabilities
boxes.append((startX, startY, endX, endY))
probs.append(prob)
# return a tuple of the bounding boxes and probabilities
return (boxes, probs)
def hardNegativeMining():
svm = cv2.ml.SVM_load(".\svm.xml")
(winW, winH) = (64, 128)
# for each scale of every image in the negative test dataset apply the sliding window technique
# get HOG descriptor of every window and use SVM to predict results
for image_file in glob.glob(".\/test\/neg\*.png"):
image = cv2.imread(image_file)
for resized in helpers.pyramid(image, scale=1.5):
for (x, y, window) in helpers.sliding_window(resized,
stepSize=32,
windowSize=(winW,
winH)):
# if the window does not meet our desired window size, ignore it
if window.shape[0] != winH or window.shape[1] != winW:
continue
winDescriptor = hog.compute(window)
rows, cols = winDescriptor.shape
winDescriptor = winDescriptor.reshape((cols, rows))
prediction = svm.predict(winDescriptor)
print(prediction)
@author: Allent_Computer
"""
# import the necessary packages
import helpers
import argparse
import time
import cv2
# load the image and define the window width and height
image = cv2.imread('E:/python/myInceptionProject/detected_image.jpg')
(winW, winH) = (60, 48)
i = 1
# loop over the image pyramid
for resized in helpers.pyramid(image, scale=1.5):
# loop over the sliding window for each layer of the pyramid
for (x, y, window) in helpers.sliding_window(resized,
stepSize=16,
windowSize=(winW, winH)):
# if the window does not meet our desired window size, ignore it
if window.shape[0] != winH or window.shape[1] != winW:
continue
# THIS IS WHERE YOU WOULD PROCESS YOUR WINDOW, SUCH AS APPLYING A
# MACHINE LEARNING CLASSIFIER TO CLASSIFY THE CONTENTS OF THE
# WINDOW
# since we do not have a classifier, we'll just draw the window
clone = resized.copy()
# cv2.rectangle(clone, (x, y), (x + winW, y + winH), (0, 255, 0), 2)
# USAGE
# python pyramid.py --image imageApp/obama.jpg
import predict
import pre_processing_data
# import imutils
from helpers import pyramid
from helpers import sliding_window
import argparse
import time
import cv2
# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--image", required=True, help="Path to the image")
ap.add_argument("-s",
"--scale",
type=float,
default=1.5,
help="scale factor size")
args = vars(ap.parse_args())
# load the image and define the window width and height
image = cv2.imread(args["image"])
# (winW, winH) = (128, 128)
for (i, resized) in enumerate(pyramid(image, scale=args["scale"])):
# show the resized image
cv2.imshow("Layer {}".format(i + 1), resized)
cv2.waitKey(0)
from helpers import pyramid
from helpers import sliding_window
import cv2
import time
if __name__ == "__main__":
image = cv2.imread('images/pedestrian.jpg')
print(image.shape)
(win_height, win_width) = (128, 128)
for layer in pyramid(image):
for (x, y, window) in sliding_window(layer,
step_size=32,
window_size=(win_width,
win_height)):
if window.shape[0] != win_height or window.shape[1] != win_width:
continue
clone = layer.copy()
cv2.rectangle(clone, (x, y), (x + win_width, y + win_height),
(0, 255, 0), 2)
cv2.imshow("Window", clone)
cv2.waitKey(1)
time.sleep(0.025)
from helpers import pyramid
from helpers import sliding_window
import cv2
import time
image = cv2.imread('sliding_window.jpg')
(winW, winH) = (128, 128)
for resized in pyramid(image, scale=1.5):
# loop over the sliding window for each layer of the pyramid
for (x, y, window) in sliding_window(resized,
stepSize=32,
windowSize=(winW, winH)):
# if the window does not meet our desired window size, ignore it
if window.shape[0] != winH or window.shape[1] != winW:
continue
# THIS IS WHERE YOU WOULD PROCESS YOUR WINDOW, SUCH AS APPLYING A
# MACHINE LEARNING CLASSIFIER TO CLASSIFY THE CONTENTS OF THE
# WINDOW
# since we do not have a classifier, we'll just draw the window
clone = resized.copy()
cv2.rectangle(clone, (x, y), (x + winW, y + winH), (0, 255, 0), 2)
cv2.imshow("Window", clone)
cv2.waitKey(1)
time.sleep(0.025)
cv2.destroyAllWindows()
from helpers import pyramid
from helpers import sliding_window
import time
import cv2
eye = cv2.imread('..\\bazy\\Webcam\\eyes\\3.jpg', 0)
(winW, winH) = (103, 31)
orb = cv2.ORB_create()
kp_eye, eye_descriptor = orb.detectAndCompute(eye, None) # find key points and computer descriptor
face = cv2.imread('..\\bazy\\Webcam\\6.jpg', 0)
matches = []
matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
# loop over the image pyramid
for resized in pyramid(face, scale=1.5):
# loop over the sliding window for each layer of the pyramid
for (x, y, window) in sliding_window(resized, stepSize=15, windowSize=(winW, winH)):
# if the window does not meet our desired window size, ignore it
if window.shape[0] != winH or window.shape[1] != winW:
continue
# clone = resized.copy()
kp_window, windows_descriptor = orb.detectAndCompute(window, None) #
match = matcher.match(eye_descriptor, windows_descriptor)
# matches.append(match)
# match = sorted(match, key=lambda x: x.distance)
print match
#
# cv2.rectangle(clone, (x, y), (x + winW, y + winH), (0, 255, 0), 2)
from helpers import pyramid
import argparse
import cv2
# construct the argument parser and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--image", required=True, help="path to the input image")
ap.add_argument("-s",
"--scale",
type=float,
default=1.5,
help="scale factor size")
args = vars(ap.parse_args())
# load the input image
image = cv2.imread(args["image"])
# loop over the layers of the image pyramid and display them
for (i, layer) in enumerate(pyramid(image, scale=args["scale"])):
cv2.imshow(f"Layer {i+1}", layer)
cv2.waitKey(0)
required=True,
type=int,
help="height of sliding window")
ap.add_argument("-s",
"--scale",
type=float,
default=1.5,
help="scale factor size")
args = vars(ap.parse_args())
# load the input image and unpack the command line arguments
image = cv2.imread(args["image"])
(winW, winH) = (args["width"], args["height"])
# loop over the image pyramid
for layer in pyramid(image, scale=args["scale"]):
# loop over the sliding window for each layer of the pyramid
for (x, y, window) in sliding_window(layer,
stepSize=32,
windowSize=(winW, winH)):
# if the current window does not meet our desired window size, ignore it
if window.shape[0] != winH or window.shape[1] != winW:
continue
# THIS IS WHERE WE WOULD PROCESS THE WINDOW, EXTRACT HOG FEATURES, AND
# APPLY A MACHINE LEARNING CLASSIFIER TO PERFORM OBJECT DETECTION
# since we do not have a classifier yet, let's just draw the window
clone = layer.copy()
cv2.rectangle(clone, (x, y), (x + winW, y + winH), (0, 255, 0), 2)
cv2.imshow("Window", clone)
from helpers import non_max_suppression_moje2
from helpers import non_max_suppression
path = 'E:\\MAGISTERSKA\\neg_test'
#rects = []
pickle_in = open('lbp_uni_2000_ahonen.pickle', 'rb')
model = pickle.load(pickle_in)
for i, file in enumerate(os.listdir(path)):
current_path = str(path) + '\\' + str(file)
print(current_path)
img = cv2.imread(current_path)
img = imutils.resize(img, width=min(400, img.shape[1]))
rects = []
for (counter,
resized) in enumerate(pyramid(img, scale=1.2, minSize=(128, 128)), 1):
###################################################################### y , x (h , w)
for (x, y, window) in sliding_window2(resized,
stepSize_h=32,
stepSize_v=16,
windowSize=(128, 64)):
############## y, h x, w
if window.shape[0] != 128 or window.shape[1] != 64:
continue
clone = resized.copy()
crop_img = clone[y:y + 128, x:x + 64]
lbp_hist = lbp2(crop_img, method='uniform')
#prediction = model.predict(lbp_hist.reshape(1, -1))
pred = model.decision_function(lbp_hist.reshape(1, -1))
#cv2.imshow('cropped', crop_img)
weight = 1.2**(counter - 1)
if len(onlyfiles) > 0:
images = numpy.empty(len(onlyfiles), dtype=object)
for n in range(0, len(onlyfiles)):
images[n] = cv2.imread(join(mypath, onlyfiles[n]))
elif (cv2.imread(args["image"]) != None):
images = numpy.empty(1, dtype=object)
images[1] = cv2.imread(args["image"])
else:
raise ValueError(
'Invalid arguments; image or directory path reference needed')
for image in images:
win_size = 16
(winW, winH) = (win_size, win_size)
for resized in pyramid(image, scale=1.5, minSize=(20, 20)):
for (x, y, window) in sliding_window(resized,
stepSize=win_size,
windowSize=(winW, winH)):
# if the window does not meet our desired window size, ignore it
if window.shape[0] != winH or window.shape[1] != winW:
continue
#CLASSIFY SHIT HERE
# since we do not have a classifier... ahem... we'll just draw the window
clone = resized.copy()
cv2.rectangle(clone, (x, y), (x + winW, y + winH), (0, 255, 0), 2)
cv2.imshow("Window", clone)
cv2.waitKey(1)
# time.sleep(0.0001)
image = cv2.imread(args["image"], cv2.IMREAD_COLOR)
# Get image name for output
imageName = args["image"].split("/")[1]
(winW, winH) = (64, 64)
# (winW, winH) = (128, 128)
start_time = datetime.datetime.now()
# loop over the image pyramid
count = 0
level = 0
scale = 1.25
lst_img = list()
lst_imgDetail = list()
ori_clone = image.copy()
for resized_image in pyramid(image, scale):
# loop over the sliding window for each layer of the pyramid
# for (x, y, window) in sliding_window(resized_image, stepSize=8, windowSize=(winW, winH)):
for (x, y, window) in sliding_window(resized_image,
stepSize=16,
windowSize=(winW, winH)):
# if the window does not meet our desired window size, ignore it
if window.shape[0] != winH or window.shape[1] != winW:
continue
# THIS IS WHERE YOU WOULD PROCESS YOUR WINDOW, SUCH AS APPLYING A
# MACHINE LEARNING CLASSIFIER TO CLASSIFY THE CONTENTS OF THE
# WINDOW
curWindow = (x, y, x + winW, y + winH)
subImage = utils.to_image(resized_image).crop(curWindow)
# DETECT PEDESTRIAN
hog = HOGDescriptor.createHOGDescriptor((64, 128), (16, 16), (8, 8),
(8, 8), 9, False)
origin_image = cv2.imread('data/Train/pos/crop001048.png')
origin_r, origin_c, _ = origin_image.shape
ratio = origin_c / origin_r
image = cv2.resize(origin_image,
None,
fx=250 / origin_c,
fy=250 / (ratio * origin_r))
r, c, _ = image.shape
print(r, c)
bounding_box = []
prob = []
for (i, layer) in enumerate(pyramid(image, 1.05, (64, 128))):
m, n, _ = layer.shape
for (x, y, window) in sliding_window(layer, 8, (64, 128)):
if window.shape[0] != 128 or window.shape[1] != 64:
continue
normalized = cv2.resize(window, (64, 128))
data = np.array([hog.compute(normalized)]).squeeze()
data = data.reshape(1, -1)
resp = model.predict_proba(data)
x_begin = int((x / n) * c)
y_begin = int((y / m) * r)
x_end = int(((x + 63) / n) * c)
y_end = int(((y + 127) / m) * r)
if resp[0][1] > resp[0][0]:
bounding_box.append((x_begin, y_begin, x_end, y_end))
