def test(self):
""" Testing images with known mat files """
if os.path.exists("./data/train_sdm.mat"):
mat = io.loadmat("./data/train_sdm.mat")
R = mat['R']
b = mat['b']
shape_x = mat['i']
# accuracy = 0
for idx, img in enumerate(self.grays):
img = copy.deepcopy(self.grays[idx])
shape_x = mat['i']
faces = self.__get_dlib_rect(img)[0]
rect = [
faces.left(),
faces.top(),
faces.right(),
faces.bottom()
]
# get extend ground truth bounding box
new_rect = self.__crop(img, rect, self.extend_rate)
# crop image
cropped = img[int(new_rect[1]):int(new_rect[3]),
int(new_rect[0]):int(new_rect[2])]
# resize image
img = self.__resize(cropped, self.new_size)
# self.__recompute_shape(cropped, self.shapes[idx], rect)
for i in range(1):
shape = Shape.turn_back_to_point(shape_x)
hog_descriptor = HOG(img, shape)
hog_x = hog_descriptor.extract()
shape_x = shape_x + np.matmul(hog_x, R[i, :]) + b[i, :]
# accuracy += self.evaluate(shape_x, self.shapes[idx].get_vector())
# print("Already completed", idx + 1, "images.")
height, width = cropped.shape[:2]
scale_x = self.new_size[0] / width
scale_y = self.new_size[1] / height
shape = Shape.turn_back_to_point(shape_x)
for pt in shape.pts:
pt.x = pt.x / scale_x - (
rect[2] - rect[0]) / self.extend_rate + rect[0]
pt.y = pt.y / scale_y - (
rect[3] - rect[1]) / self.extend_rate + rect[1]
# print("Accuracy:", accuracy/len(self.shapes))
return shape
return
def main():
root = os.path.dirname(os.path.abspath(__file__))
cifar_path = os.path.join('datasets', 'cifar-10')
texture_path = os.path.join('datasets', 'texture')
faces_path = os.path.join('datasets', 'faces')
cifar10 = Cifar10(root, cifar_path)
cifar10.read_data()
cifar10.rotate_images()
desc_texture = DescribableTexture(root, texture_path)
desc_texture.split_data()
faces = Faces(root, faces_path)
faces.split_data()
hog = HOG(show_images=False)
lbp = LBP(show_images=False)
datasets = [cifar10, desc_texture, faces]
descriptors = [lbp, hog]
for dataset in datasets:
for descriptor in descriptors:
print('--------------------------------------------------------')
print('Results for {} on {}:'.format(descriptor.__class__.__name__,
dataset.__class__.__name__))
descriptor.apply(dataset.train_data)
clf = LinearSVC()
clf = clf.fit(descriptor.descriptor, dataset.train_labels)
descriptor.apply(dataset.test_data)
predictions = clf.predict(descriptor.descriptor)
score = clf.score(descriptor.descriptor, dataset.test_labels)
print('Score = {}'.format(score))
print(
classification_report(dataset.test_labels,
predictions,
target_names=dataset.labels_names))
cm = confusion_matrix(dataset.test_labels, predictions)
ax = plt.subplot()
sns.heatmap(cm, annot=True)
ax.set_xlabel('Predicted labels')
ax.set_ylabel('True labels')
ax.set_title('Confusion Matrix for {}'.format(
descriptor.__class__.__name__))
ax.xaxis.set_ticklabels(dataset.labels_names)
ax.yaxis.set_ticklabels(dataset.labels_names)
plt.show()
print('--------------------------------------------------------')
print('\n\n')
from sklearn.svm import LinearSVC
from hog import HOG
import dataset
import argparse
ap = argparse.ArgumentParser()
ap.add_argument("-d", "--dataset", required=True,
help="path to the dataset file")
ap.add_argument("-m", "--model", required=True,
help="path to where the model will be stored")
args = vars(ap.parse_args())
(digits, target) = dataset.load_digits(args["dataset"])
data = []
hog = HOG(orientations=18, pixelspercell=(10, 10),
cellsperblock=(1, 1), transform=True)
for image in digits:
image = dataset.deskew(image, 20)
image = dataset.center_extent(image, (20, 20))
hist = hog.describe(image)
data.append(hist)
# instantiate random for reproducible results
model = LinearSVC(random_state=42)
model.fit(data, target)
joblib.dump(model, args["model"])
ap = argparse.ArgumentParser()
ap.add_argument("-c",
"--conf",
required=True,
help="path to the configuration file")
args = vars(ap.parse_args())
# load the configuration file and initialize the data list
conf = Conf(args["conf"])
data = []
# load the classifier, then initialize the Histogram of Oriented Gradients descriptor
# and the object detector
model = cPickle.loads(open(conf["classifier_path"]).read())
hog = HOG(orientations=conf["orientations"],
pixelsPerCell=tuple(conf["pixels_per_cell"]),
cellsPerBlock=tuple(conf["cells_per_block"]),
normalize=conf["normalize"])
od = ObjectDetector(model, hog)
# grab the set of distraction paths and randomly sample them
dstPaths = list(paths.list_images(conf["image_distractions"]))
dstPaths = random.sample(dstPaths, conf["hn_num_distraction_images"])
# setup the progress bar
widgets = [
"Mining: ",
progressbar.Percentage(), " ",
progressbar.Bar(), " ",
progressbar.ETA()
]
pbar = progressbar.ProgressBar(maxval=len(dstPaths), widgets=widgets).start()
def train_landmarks(self):
""" Training face landmarks with Lasso function """
# crop and resize training images
orders, detect_box = self.__get_detection()
self.__reload(orders)
self.__crop_and_resize(detect_box)
hog = []
shapes = []
for idx in range(len(self.grays)):
print("Calculating ", idx, "th HOG features of training images...")
# get hog features
hog_descriptor = HOG(self.grays[idx], self.shapes[idx])
h = hog_descriptor.extract()
hog.append(h)
# get shape vector list
s = Shape.get_vector(self.shapes[idx])
shapes.append(s)
# true hog features and true shapes
hog_star = np.array(hog)
shapes_star = np.array(shapes)
# get mean shape as x0
#pdm = PointDistributionModel(self.shapes)
#x0 = pdm.mean
x0 = self.__get_mean_shape().get_vector()
shape_x = np.array([x0.tolist()] * len(self.grays))
# parameters we need
R = []
b = []
# training
for i in range(self.iterates):
# delta shape vector
delta_x = shapes_star - shape_x
# hog features of computed shapes
hog_x = np.zeros_like(hog_star)
for j in range(len(self.grays)):
# get hog features
hog_descriptor = HOG(self.grays[j],
Shape.turn_back_to_point(shape_x[j]))
h = hog_descriptor.extract()
hog_x[j, :] = h
# linear regression
if self.alpha == 0:
reg = LinearRegression(fit_intercept=False)
else:
#reg = LinearRegression()
#reg = SVR()
#reg = Ridge(alpha=self.alpha)
reg = Lasso(alpha=self.alpha)
print("Calculating with Linear Regression...")
reg.fit(hog_x, delta_x)
R.append(reg.coef_.T)
b.append(reg.intercept_.T)
shape_x = shape_x + np.matmul(hog_x, R[i]) + b[i]
# x0 = x0.tolist()
io.savemat("./data/train_sdm", {"R": R, "b": b, "i": x0})
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-m",
"--model",
required=True,
help="path to where the model will be stored")
ap.add_argument("-i", "--image", required=True, help="path to the image file")
args = vars(ap.parse_args())
# load the model
model = joblib.load(args["model"])
# initialize the HOG descriptor
hog = HOG(orientations=9,
pixelsPerCell=(4, 4),
cellsPerBlock=(2, 2),
normalize=True)
# load the image and convert it to grayscale
image = cv2.imread(args["image"])
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# blur the image, find edges, and then find contours along the edged regions
blurred = cv2.GaussianBlur(gray, (5, 5), 0)
edged = cv2.Canny(blurred, 30, 150)
(cnts, _) = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
# sort the contours by their x-axis position, ensuring that we read the numbers from
# left to right
cnts = sorted([(c, cv2.boundingRect(c)[0]) for c in cnts], key=lambda x: x[1])
from hog import HOG
import cv2
img = cv2.imread("tes.pgm",cv2.IMREAD_GRAYSCALE)
cobaa = HOG(img)
x,y = cobaa.gradient()
# print "X =",x
# print "y =",y
"Error: command line should look like: \"python <fileName.py> <target image> <video file>\""
)
sys.exit()
# read video
video = cv2.VideoCapture(sys.argv[2])
# exit if video not opened
if not video.isOpened():
print("Error: Could not open video")
sys.exit()
# create HOG and feature descriptor
hogImage = cv2.imread(sys.argv[1])
hogImage = hogify(hogImage, 128, 128)
targetFD = HOG(hogImage)
# while we do not have 10 consecutive frames that have changed
print("Processing video... ")
while not contiguousPassed:
while imageIsBlack:
# get first frame and resize if ok
ok, frame = video.read()
frameCheck(ok)
frame = imutils.resize(frame, width=800)
# get second frame and resize if ok
ok2, frame2 = video.read()
frameCheck(ok2)
frame2 = imutils.resize(frame2, width=800)
argument_parser = argparse.ArgumentParser()
argument_parser.add_argument('-d',
'--dataset',
required=True,
help='Path to the dataset file.')
argument_parser.add_argument('-m',
'--model',
required=True,
help='Path to where the model will be stored.')
arguments = vars(argument_parser.parse_args())
(digits, target) = dataset.load_digits(arguments['dataset'])
data = []
hog = HOG(orientations=18,
pixels_per_cell=(10, 10),
cells_per_block=(1, 1),
transform=True)
for image in digits:
image = dataset.deskew(image, 20)
image = dataset.center_extent(image, (20, 20))
histogram = hog.describe(image)
data.append(histogram)
model = LinearSVC(random_state=42)
model.fit(data, target)
joblib.dump(model, arguments['model'])
class Controller:
def __init__(self):
from hog import HOG
self.hog_generator = HOG()
def load_batch(self,path):
'''
Loading a image batch
'''
batch_loader = ImageLoader()
return batch_loader.load_image(path)
def grascale(self,image_batch):
'''
images are loaded bgr
convert from rgb to gray
'''
new_batch = []
for image in image_batch:
frame = 0.114 * image[:,:,0] + 0.587 * image[:,:,1] + 0.299 * image[:,:,2]
new_batch.append(frame)
return new_batch
def genearte_hog(self,image_batch):
'''
Hook to generate hog, written to handle batches
'''
batch = []
for image in image_batch:
descriptor = self.hog_generator.generate_hog_features(image,(8,8),2)
batch.append(descriptor)
return batch
def randomize_input_batch(self,batch1,batch2):
'''
Randomize dataset for training
'''
import random
batch = []
label = []
for _ in range(len(batch1 + batch2)):
# randomly picking a positive or a negative sample
r = random.randint(0,1)
if (r == 1):
try:
batch.append(batch1[0])
label.append(1)
batch1 = batch1[1:]
except:
batch.append(batch2[0])
label.append(0)
batch2 = batch2[1:]
if (r == 0):
try:
batch.append(batch2[0])
label.append(0)
batch2 = batch2[1:]
except:
batch.append(batch1[0])
label.append(1)
batch1 = batch1[1:]
return batch,label
def run(self):
'''
Main running function
'''
# loading image batch
print("Loading image")
train_positive = self.load_batch("./Train_positive/")
train_negative = self.load_batch("./Train_negative/")
test_positive = self.load_batch("./Test_positive/")
test_negative = self.load_batch("./Test_negative/")
print(len(test_positive))
print("Image Batch Loaded")
# Generating grascale images
print("Converting to grayscale")
train_positive_gray = self.grascale(train_positive)
train_negative_gray = self.grascale(train_negative)
test_positive_gray = self.grascale(test_positive)
test_negative_gray = self.grascale(test_negative)
print("Grayscale computed")
print("Extracting HOG descriptor")
# Extracting Hog features for training images
train_positive_descriptor = self.genearte_hog(train_positive_gray)
train_negative_descriptor = self.genearte_hog(train_negative_gray)
test_positive_descriptor = self.genearte_hog(test_positive_gray)
test_negative_descriptor = self.genearte_hog(test_negative_gray)
print("Extracted descriptor")
# training a neural net
for num_neuron in [250,500,1000]:
nn = NeuralNetwork(1, [num_neuron], 0.05)
X_, Y_ = self.randomize_input_batch(train_positive_descriptor,train_negative_descriptor)
X_train = np.array(X_, dtype=np.float32)
y_train = np.array(Y_, dtype=np.int32)
nn.train(X_train,y_train)
# testing the network
x_, y_ = self.randomize_input_batch(test_positive_descriptor, test_negative_descriptor)
X_test = np.array(test_positive_descriptor + test_negative_descriptor, dtype=np.float32)
Y_test = np.array(len(test_positive_descriptor) * [1] + len(test_negative_descriptor) * [0], dtype=np.int32)
y_pred = nn.predict(X_test)
"""## Results and final comment"""
print(nn.accuracy(y_pred,Y_test))
print("->>>>>>>>>>>>>>>>>>>")
print(y_pred)
print("-..................")
print(Y_test)
def __init__(self):
from hog import HOG
self.hog_generator = HOG()
import dataset
import argparse
import mahotas
import cv2
ap = argparse.ArgumentParser()
ap.add_argument('-m','--model', required=True,
help='path to where the model is stored')
ap.add_argument('-i','--image', required=True,
help = 'path to images')
args = vars(ap.parse_args())
model = joblib.load(args['model'])
hog = HOG(orientations = 18, pixelsPerCell=(10,10),
cellsPerBlock=(1,1), normalize=True)
image = cv2.imread(args['image'])
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (5,5), 0)
edged = cv2.Canny(blurred, 30, 150)
(_, cnts, _) = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = sorted([(c, cv2.boundingRect(c)[0]) for c in cnts],
key = lambda x: x[1])
for (c, _) in cnts:
(x, y, w, h) = cv2.boundingRect(c)
from __future__ import print_function
import joblib
from hog import HOG
import argparse
import mahotas
import cv2
ap = argparse.ArgumentParser()
ap.add_argument("-m",
"--model",
required=True,
help="path to where model will be stored")
ap.add_argument("-i", "--image", required=True, help="path to the image file")
args = vars(ap.parse_args())
model = joblib.load(args["model"])
hog = HOG(orientations=18,
pixelsPerCell=(10, 10),
cellsPerBlock=(1, 1),
transform=True)
image = cv2.imread(args["image"])
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blurred = cv2.GaussianBlur(gray, (5, 5), 0)
edged = cv2.Canny(blurred, 30, 150)
cnts, _ = cv2.findContours(edged.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_SIMPLE)
cnts = sorted([(c, cv2.boundingRect(c)[0]) for c in cnts], key=lambda x: x[1])
for (c, _) in cnts:
(x, y, w, h) = cv2.boundingRect(c)
if w >= 7 and h >= 20:
roi = gray[y:y + h, x:x + w]
thresh = roi.copy()
T = mahotas.thresholding.otsu(roi)
ap = argparse.ArgumentParser()
ap.add_argument("-m",
"--model",
required=True,
help="path to where the model will be stored")
ap.add_argument("-i", "--image", required=True, help="path to the image file")
ap.add_argument("-f", "--face", required=True, help="path to face cascade")
args = vars(ap.parse_args())
# load the model
model = open(args["model"]).read()
model = cPickle.loads(model)
# initialize the HOG descriptor
hog = HOG(orientations=40,
pixelsPerCell=(10, 10),
cellsPerBlock=(1, 1),
normalize=True)
# load the image and convert it to grayscale
image = cv2.imread(args["image"])
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
fd = Facedetector(args["face"])
faces = fd.detect(gray, scaleFactor=1.2, minNeighbors=3, minSize=(30, 30))
#cv2.imshow('img',gray)
if (len(faces) == 0):
image = cv2.resize(image, (47, 62), interpolation=cv2.INTER_AREA)
else:
(x, y, w, h) = faces[0]
roi_color = image[y:y + h, x:x + w]
image = cv2.resize(roi_color, (47, 62), interpolation=cv2.INTER_AREA)
ap.add_argument("-m",
"--model",
default="svm.pickle",
help="path to where the model will be stored")
args = vars(ap.parse_args())
print("Collecting annotations ...")
#CHANGE 'inflammed aorta' to the disease which you are working to diagnose
d = Dataset(myDirectory, myDirectory, ['inflamed aorta'])
labels, images = d.load_data()
print("Gathered {} image slices".format(len(images)))
data = []
labels_new = []
hog = HOG(orientations=19,
pixelsPerCell=(8, 8),
cellsPerBlock=(3, 3),
transform=True)
for i, image in enumerate(images):
if i % 100 == 0:
print("Gathering features, {} of {}".format(i, len(images)))
if 0 not in image.shape:
image_resized = resize(image, (291, 218), anti_aliasing=True)
hist = hog.describe(rgb2gray(image_resized))
data.append(hist)
labels_new.append(labels[i])
X_train, X_test, y_train, y_test = train_test_split(data,
labels_new,
random_state=0)
print("Training on {} images".format(len(X_train)))
import pickle
import dataset
import argparse
from hog import HOG
from sklearn.svm import LinearSVC
ap = argparse.ArgumentParser()
ap.add_argument("-t", "--train", required=True, help="train.csv path")
ap.add_argument("-m",
"--model",
required=True,
help="path of where model will be saved")
args = vars(ap.parse_args())
digits, labels = dataset.load_digits(args["train"])
hog = HOG(orientations=18,
pixels_per_cell=(6, 6),
cells_per_block=(1, 1),
transform=True)
data = []
for digit in digits:
hist = hog.describe(digit)
data.append(hist)
model = LinearSVC()
model.fit(data, labels)
pickle.dump(model, open(args["model"], 'wb'))
negative = Controller().load_batch("./Test_negative/")
print(len(positive))
positive = Controller().grascale(positive)
negative = Controller().grascale(negative)
print(len(positive))
i = 0
for image in positive:
i += 1
grad_x, grad_y = Canny().gradient_generation(image)
egde_mag = Canny().edge_magnitude(grad_x, grad_y)
cv2.imwrite("./results/Postive" + str(i) + ".jpg", egde_mag)
i = 0
for image in negative:
i += 1
grad_x, grad_y = Canny().gradient_generation(image)
egde_mag = Canny().edge_magnitude(grad_x, grad_y)
cv2.imwrite("./results/Negative" + str(i) + ".jpg", egde_mag)
image = cv2.imread("./Train_positive/crop001278a.bmp")
image = 0.114 * image[:, :, 0] + 0.587 * image[:, :, 1] + 0.299 * image[:, :,
2]
descriptor = HOG().generate_hog_features(image, (8, 8), 2)
np.savetxt("crop001278a.csv", descriptor.flatten(), delimiter="\n")
image = cv2.imread("./Test_positive/crop001045b.bmp")
image = 0.114 * image[:, :, 0] + 0.587 * image[:, :, 1] + 0.299 * image[:, :,
2]
descriptor = HOG().generate_hog_features(image, (8, 8), 2)
np.savetxt("crop001045b.csv", descriptor.flatten(), delimiter="\n")
from sklearn.svm import LinearSVC
from hog import HOG
import dataset
import argparse
ap = argparse.ArgumentParser()
ap.add_argument('-d', '--dataset', required=True,
help = 'Path to the dataset file')
ap.add_argument('-m', '--model', required = True,
help='path to where the model will be stored')
args = vars(ap.parse_args())
(digits, target) = dataset.load_digits(args['dataset'])
data = []
hog = HOG(orientations = 18, pixelsPerCell=(10, 10),
cellsPerBlock=(1,1), normalize=True)
for image in digits:
image = dataset.deskew(image, 20)
image = dataset.center_extent(image, (20, 20))
hist = hog.describe(image)
data.append(hist)
model = LinearSVC(random_state = 42)
model.fit(data, target)
joblib.dump(model, args['model'])
# print 'I don\'t give a shit'
def main():
#-model=./modelo -image=./imagen.jpg
#Para pasarle los argumentos
argumento = argparse.ArgumentParser()
argumento.add_argument('-model',
'--model',
required=True,
help="path where the training model is saved")
argumento.add_argument(
"-image",
"--image",
required=True,
help="path where the image, which is going to be clasified, is saved")
#Se le asigna el primer argumento a la ruta del modelo de entrenamiento
args = vars(argumento.parse_args())
model_path = args['model']
#Se le asigna el segundo argumento ala ruta de la imagen que se va a clasificar
image_path = args['image']
#Se carga el entrenamiento
model = cPickle.load(file(model_path))
#Se carga la imagen
image = cv2.imread(image_path)
#escalo la imagen porque me sale muy grande
h, w = image.shape[:2]
image = cv2.resize(image, (w / 4, h / 4), interpolation=cv2.INTER_AREA)
#A escala de grises
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
#Filtro gausiano
blur = cv2.GaussianBlur(gray_image, (5, 5), 0)
#Bordes canny
edges = cv2.Canny(blur, 150, 100)
#Extraer contornos
ima, ctrs, hier = cv2.findContours(edges, cv2.CHAIN_APPROX_SIMPLE,
cv2.RETR_TREE)
#Obtenemos los recangulos de cada contorno
rects = [cv2.boundingRect(ctr) for ctr in ctrs]
#Definimos los parametros de la Transformada de hog
hog = HOG(orientations=18,
pixelsPerCell=(10, 10),
cellsPerBlock=(1, 1),
normalize=True)
for rect in rects:
#Draw the rectangles
cv2.rectangle(image, (rect[0], rect[1]),
(rect[0] + rect[2], rect[1] + rect[3]), (0, 255, 0), 3)
# Make the rectangular region around the digit
leng = int(rect[3] * 1.6)
pt1 = int(rect[1] + rect[3] // 2 - leng // 2)
pt2 = int(rect[0] + rect[2] // 2 - leng // 2)
#Se recorta la region
crop_region = gray_image[pt1:pt1 + leng, pt2:pt2 + leng]
#Umbralizado de otsu e invertimos la imaagen
ret, threshold = cv2.threshold(crop_region, 177, 255,
cv2.THRESH_OTSU + cv2.THRESH_BINARY_INV)
threshold = dataset.deskew(threshold, 20)
threshold = dataset.center_extent(threshold, (20, 20))
#Se obtiene el digito a partir del modelo de gradiente orientado y del modelo de entramiento
hist = hog.describe(threshold)
digit = model.predict(hist)[0]
#Se dibuja el digito correspondiente
cv2.putText(image, str(int(digit)), (rect[0], rect[1]),
cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
cv2.imshow('ventana', image)
cv2.waitKey()
from __future__ import print_function
from sklearn.externals import joblib
from hog import HOG
import dataset
import argparse
import mahotas
import cv2
ap=argparse.ArgumentParser()
ap.add_argument('-m','--model',required=True,help='Path to where the model will be stored')
ap.add_argument('-i','--image',required=True,help='Path to the image file')
args=vars(ap.parse_args())
model=joblib.load(args['model'])
hog=HOG(orientations=18,pixelsPerCell=(10,10),cellsPerBlock=(1,1),transform=True)
image=cv2.imread(args['image'])
gray=cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
blurred=cv2.GaussianBlur(gray,(5,5),0)
edged=cv2.Canny(blurred,30,150)
(_,cnts,_)=cv2.findContours(edged.copy(),cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
cnts=sorted([(c,cv2.boundingRect(c)[0]) for c in cnts], key = lambda x: x[1])
for (c,_) in cnts:
(x,y,w,h)=cv2.boundingRect(c)
if w>=7 and h>=20:
roi=gray[y:y+h,x:x+w]
thresh=roi.copy()
required=True,
help="Path to the configuration file")
ap.add_argument("-i",
"--image",
required=True,
help="Path to the image to be classified")
args = vars(ap.parse_args())
# load the configuration file
conf = Conf(args["conf"])
#load the classifier, then initialize the HOG descriptors
# and the object detector
model = cPickle.loads(open(conf["classifier_path"]).read())
hog = HOG(orientations=conf["orientations"],
pixelsPerCell=tuple(conf["pixels_per_cell"]),
cellsPerBlock=tuple(conf["cells_per_block"]),
normalize=conf["normalize"])
od = ObjectDetector(model, hog)
# load the image and convert it to grayscale
image = cv2.imread(args["image"])
image = imutils.resize(image, width=min(128, image.shape[1]))
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blur = cv2.GaussianBlur(gray, (5, 5), 0)
ret, thresh = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
opening = cv2.morphologyEx(gray, cv2.MORPH_OPEN, kernel)
edges = cv2.Canny(opening, ret, ret * 0.95)
# detect objects in the image and apply non-maxima supression to the bounding boxes
(boxes, probs) = od.detect(edges,
