def haar_feature_fit(pos_dir, neg_dir):
para = [[]]
y = []
classi = ensemble.AdaBoostClassifier(
tree.DecisionTreeClassifier(max_depth=2),
algorithm="SAMME.R",
n_estimators=50,
learning_rate=1.2)
for root, director, files in os.walk(pos_dir):
print(files)
i = 0
for file in files:
i += 1
if (i > 50):
break
print(file)
image = io.imread(pos_dir + file)
img_gray = color.rgb2gray(image)
img_union = transform.resize(img_gray, (190, 100))
coord, ft = haar_like_feature_coord(100, 60, feature_types[0])
feature = haar_like_feature(img_union, 0, 0, 100, 60, ft, coord)
para = np.array([feature])
#y = np.array(1)
classi.fit(para, [0])
for root, director, files in os.walk(neg_dir):
print(files)
i = 0
for file in files:
i += 1
if (i > 50):
break
print(file)
image = io.imread(neg_dir + file)
img_gray = color.rgb2gray(image)
coord, ft = haar_like_feature_coord(100, 60, feature_types[0])
feature = haar_like_feature(img_gray, 0, 0, 100, 60, ft, coord)
para = np.array([feature])
#y = np.array(0)
classi.fit(para, [0])
joblib.dump(classi, "D:/dataset/haarmodel.m")
image = io.imread(
"D:/dataset/ccpd_select1/242&422_86&414_80&364_235&372-0_0_16_32_11_32_26.jpg"
)
img_gray = color.rgb2gray(image)
coord, ft = haar_like_feature_coord(100, 60, feature_types[0])
feature = haar_like_feature(img_gray, 0, 0, 100, 60, ft, coord)
test = np.array([feature])
res = classi.predict(test)
print(res)
def haar(img):
img = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
img_ii = integral_image(img)
haar_2x = haar_like_feature(img_ii, 0, 0, 5, 5, 'type-2-x')
haar_2y = haar_like_feature(img_ii, 0, 0, 5, 5, 'type-2-y')
haar_3x = haar_like_feature(img_ii, 0, 0, 5, 5, 'type-3-x')
haar_3y = haar_like_feature(img_ii, 0, 0, 5, 5, 'type-3-y')
haar_4 = haar_like_feature(img_ii, 0, 0, 5, 5, 'type-4')
haar = np.concatenate([haar_2x, haar_2y, haar_3x, haar_3y, haar_4])
return haar
def test_haar_like_feature_list():
img = np.ones((5, 5), dtype=np.int8)
img_ii = integral_image(img)
feature_type = ['type-2-x', 'type-2-y', 'type-3-x', 'type-3-y', 'type-4']
haar_list = haar_like_feature(img_ii,
0,
0,
5,
5,
feature_type=feature_type)
haar_all = haar_like_feature(img_ii, 0, 0, 5, 5)
assert_array_equal(haar_list, haar_all)
def haar_features(train, test, feature_maps):
train_harr=[]
test_harr=[]
for i in train:
img_ii=integral_image(i)
feature=haar_like_feature(img_ii,0,0,20,20,feature_maps)
train_harr.append(feature)
for i in test:
img_ii=integral_image(i)
feature=haar_like_feature(img_ii,0,0,20,20,feature_maps)
test_harr.append(feature)
train_harr=np.array(train_harr)
test_harr=np.array(test_harr)
return train_harr, test_harr
def haar_feature_descriptor(img, type, feature_coords=None, feature_type=None):
integ_img = integral_image(img)
if type == 0:
features = haar_like_feature(integ_img, 0, 0, img.shape[1],
img.shape[0], feature_types)
else:
features = haar_like_feature(integ_img,
0,
0,
img.shape[1],
img.shape[0],
feature_type=feature_type,
feature_coord=feature_coords)
#print(len(features))
return features
def haar_compute(integral_images, top_left_x, top_left_y, width_, height_,
feature_type_):
"""
Compute Haar-like features with given parameters
:param integral_images : list of integral images for feature computation
:param top_left_x : top left window corner(row)
:param top_left_y : top left window corner(col)
:param width_ : window width
:param height_ : window height
:param feature_type_ : type of Haar-like feature(check scikit-image docs)
:return: haar_feature_vector: a vector of haar like features for each image
shape: (no_of_images, no_of_features)
-> one row corresponds to one image
"""
haar_feature_vector = [
haar_like_feature(int_image=integral_image,
r=top_left_x,
c=top_left_y,
width=width_,
height=height_,
feature_type=feature_type_)
for integral_image in integral_images
]
return haar_feature_vector
def haar_like_features(image):
"""calculates the set of haar-like features
Calculates the haar-like per channel. It first reshape the image to 64*64*C and
then calcualtes the ['type-2-x', 'type-2-y'] features.
For more info please refer to:
https://scikit-image.org/docs/dev/auto_examples/applications/plot_haar_extraction_selection_classification.html
Parameters
----------
image : 3D array, shape (M, N, C)
The input image with multiple channels.
Returns
-------
features : dict
dictionary including haar_1_Ch1, haar_2_Ch1 ...
"""
# storing the feature values
features = dict()
for ch in range(image.shape[2]):
temp_image = resize(image[:, :, ch].copy(), (64, 64))
ii = integral_image(temp_image)
haar_fatures = haar_like_feature(ii, 0, 0, ii.shape[0], ii.shape[1],
['type-2-x', 'type-2-y'])
for i in range(len(haar_fatures)):
features["haar_" + str(i + 1) + "_Ch" +
str(ch + 1)] = haar_fatures[i]
return features
def sliding_window_(image, stepSize, windowSize):
for y in range(0, image.shape[0]):
for x in range(0, image.shape[1]):
window = image[x:x + windowSize, y:y + windowSize]
cv2.namedWindow('Digito1', cv2.WINDOW_NORMAL)
cv2.imshow('Digito1', window)
clone = image.copy()
cv2.rectangle(image, (x, y), (x + windowSize, y + windowSize),
(0, 255, 0), 0)
cv2.namedWindow('Digito2', cv2.WINDOW_NORMAL)
cv2.imshow('Digito2', clone)
cv2.waitKey()
cv2.destroyAllWindows()
try_window_feature = integral_image(window)
features = haar_like_feature(try_window_feature, 0, 0, 5, 5,
feature_types)
print(features)
print('sliding window')
print(len(features))
features_windows.append(features)
print(len(features_windows))
'''windows.append(window)
print('cantidad de ventanas: ', len(windows))'''
return features_windows
def get_haar_features(digits, type='type-2-x'):
from skimage.feature import haar_like_feature
X = []
_, w, h = digits.shape
for digit in digits:
X.append(haar_like_feature(digit, 0, 0, w, h, feature_type=type))
return np.array(X)
def scikit_feature(img, feature):
ii = integral_image(img)
return haar_like_feature(ii,
0,
0,
img.shape[0],
img.shape[1],
feature_type=feature)
def extract_feature_image(img, feature_type, feature_coord=None):
ii = integral_image(img)
return haar_like_feature(ii,
0,
0,
ii.shape[0],
ii.shape[1],
feature_type=feature_type,
feature_coord=feature_coord)
def extract_feature_image(img, feature_type, feature_coord=None):
"""Extract the haar feature for the current image"""
# compute integral image
ii = integral_image(img)
# return list of all haar features in image
return haar_like_feature(ii, 0, 0, ii.shape[0], ii.shape[1],
feature_type=feature_type,
feature_coord=feature_coord)
def process_image(image, args=object):
if args.DES_TYPE == "HOG":
fd = hog(image, block_norm='L2', pixels_per_cell=args.PIXELS_PER_CELL)
elif args.DES_TYPE == "LBP":
fd = lbp(image, args.LBP_POINTS, args.LBP_RADIUS)
elif args.DES_TYPE == "HAAR":
fd = haar_like_feature(integral_image(image), 0, 0, 5, 5, 'type-3-x')
else:
raise KeyError("==> The Processing method does not exist!")
return fd
def extract_feature_image(img, feature_type, feature_coord=None):
"""Extract the haar feature for the current image"""
ii = integral_image(img)
return haar_like_feature(ii,
0,
0,
ii.shape[0],
ii.shape[1],
feature_type=feature_type,
feature_coord=feature_coord)
def test_haar_like_feature_error():
img = np.ones((5, 5), dtype=np.float32)
img_ii = integral_image(img)
feature_type = 'unknown_type'
with pytest.raises(ValueError):
haar_like_feature(img_ii, 0, 0, 5, 5, feature_type=feature_type)
haar_like_feature_coord(5, 5, feature_type=feature_type)
draw_haar_like_feature(img, 0, 0, 5, 5, feature_type=feature_type)
feat_coord, feat_type = haar_like_feature_coord(5, 5, 'type-2-x')
with pytest.raises(ValueError):
haar_like_feature(img_ii,
0,
0,
5,
5,
feature_type=feat_type[:3],
feature_coord=feat_coord)
def _compute_for_roi(self, region_of_interest):
height, width = region_of_interest.shape[:2]
desc = haar_like_feature(region_of_interest,
width=width,
height=height,
r=0,
c=0)
desc = np.reshape(desc, (1, -1))
return desc
def extract_feature_image(self, img, feature_type, feature_coord=None):
# Extract the haar feature for the current image
# Integral image is computed for optimization of convolution operation
ii = integral_image(img)
return haar_like_feature(ii,
0,
0,
ii.shape[0],
ii.shape[1],
feature_type=feature_type,
feature_coord=feature_coord)
def test_haar_like_feature(feature_type, shape_feature, expected_feature_value,
dtype):
# test Haar-like feature on a basic one image
img = np.ones((5, 5), dtype=dtype)
img_ii = integral_image(img)
haar_feature = haar_like_feature(img_ii,
0,
0,
5,
5,
feature_type=feature_type)
assert_allclose(np.sort(np.unique(haar_feature)), expected_feature_value)
def test_haar_like_feature_precomputed(feature_type):
img = np.ones((5, 5), dtype=np.int8)
img_ii = integral_image(img)
if isinstance(feature_type, list):
# shuffle the index of the feature to be sure that we are output
# the features in the same order
shuffle(feature_type)
feat_coord, feat_type = zip(
*
[haar_like_feature_coord(5, 5, feat_t) for feat_t in feature_type])
feat_coord = np.concatenate(feat_coord)
feat_type = np.concatenate(feat_type)
else:
feat_coord, feat_type = haar_like_feature_coord(5, 5, feature_type)
haar_feature_precomputed = haar_like_feature(img_ii,
0,
0,
5,
5,
feature_type=feat_type,
feature_coord=feat_coord)
haar_feature = haar_like_feature(img_ii, 0, 0, 5, 5, feature_type)
assert_array_equal(haar_feature_precomputed, haar_feature)
def test_haar_like_feature_fused_type(dtype, feature_type):
# check that the input type is kept
img = np.ones((5, 5), dtype=dtype)
img_ii = integral_image(img)
expected_dtype = img_ii.dtype
# to avoid overflow, unsigned type are converted to signed
if 'uint' in expected_dtype.name:
expected_dtype = np.dtype(expected_dtype.name.replace('u', ''))
haar_feature = haar_like_feature(img_ii,
0,
0,
5,
5,
feature_type=feature_type)
assert haar_feature.dtype == expected_dtype
def process_image(self, image):
'''
This function is used to extract features from input image
according to the config
:param image: input image
:return: The features extracted from input image
'''
if self.config.DES_TYPE == "HOG":
fd = hog(image,
block_norm='L2',
pixels_per_cell=self.config.PIXELS_PER_CELL)
elif self.config.DES_TYPE == "LBP":
fd = lbp(image, self.config.LBP_POINTS, self.config.LBP_RADIUS)
elif self.config.DES_TYPE == "HAAR":
fd = haar_like_feature(integral_image(image), 0, 0, 5, 5,
'type-3-x')
else:
raise KeyError("==> The Processing method does not exist!")
return fd
def detection(img):
width = img.shape[0]
height = img.shape[1]
print(height)
ptr_w = 0
ptr_h = 0
classi = joblib.load("D:/dataset/haarmodel.m")
while ptr_h < height:
while ptr_w < width:
part_img = img[ptr_w:ptr_w + 60, ptr_h:ptr_h + 100]
img_gray = color.rgb2gray(part_img)
io.imshow(img_gray)
io.show()
coord, ft = haar_like_feature_coord(100, 60, feature_types[0])
feature = haar_like_feature(img_gray, 0, 0, 100, 60, ft, coord)
test = np.array([feature])
res = classi.predict(test)
if res == 1:
print("PL detected")
else:
print("NOT detected" + str(ptr_w) + "_" + str(ptr_h))
if (ptr_w + 90) == width:
ptr_w = width + 1
else:
ptr_w += 70
if (ptr_w + 70) > width:
ptr_w = width - 90
ptr_w = 0
if (ptr_h + 100) == height:
ptr_h = height + 1
else:
ptr_h += 100
if (ptr_h + 100) > height:
print("end")
ptr_h = height - 100
elif sourcer_params['color_model'] == "hls":
img = cv2.cvtColor(img, cv2.COLOR_RGB2HLS)
elif sourcer_params['color_model'] == "yuv":
img = cv2.cvtColor(img, cv2.COLOR_RGB2YUV)
elif sourcer_params['color_model'] == "ycrcb":
img = cv2.cvtColor(img, cv2.COLOR_RGB2YCR_CB)
elif sourcer_params['color_model'] == "grey":
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
else:
raise Exception('ERROR:', 'No se puede cambiar de color')
'''hogA_img = img[:, :, 0]
hogB_img = img[:, :, 1]
hogC_img = img[:, :, 2]'''
return img#, hogA_img, hogB_img, hogC_img
svm = joblib.load('D:\Documents\OPENCV\MODELS\HAAR_SVM_MODEL_0.9501557632398754.pkl')
img = cv2.imread('D:\\Documents\\OPENCV\\TRAINING\\6.jpg')
imgGREY = change_color(img, sourcer_params)
imgX = integral_image(imgGREY)
features = haar_like_feature(imgX, 0, 0, 40, 40, feature_types)
nbr = svm.predict(np.array([features]))
print(nbr[0])
end = timer()
print("{0:.3f}".format(end - start)+' seconds') # Time in seconds
def haar_feature(img,feature_type_):
int_img = integral_image(img)
return haar_like_feature(int_img, 0, 0, int_img.shape[0],int_img.shape[1],feature_type_)
def get_adaboost_haar(img,index_,f_type,f_coord):
int_img = integral_image(np.asarray(img))
return haar_like_feature(int_img, 0, 0, int_img.shape[0],int_img.shape[1],\
f_type[index_:index_+1],f_coord[index_:index_+1])
feat_coord = np.delete(feat_coord, i)
feat_type = np.delete(feat_type, i)
else:
i += 1
# one over 4
feat_coord = feat_coord[::4]
feat_type = feat_type[::4]
print('features', feat_coord.shape)
first = True
for image in x_train:
int_image = transform.integral_image(image)
features = feature.haar_like_feature(int_image,
0,
0,
28,
28,
feature_type=feat_type,
feature_coord=feat_coord)
if first:
ftrain = [features]
else:
ftrain = np.append(ftrain, [features], axis=0)
first = False
# TRAINING
myboosting = ensemble.AdaBoostClassifier(n_estimators=50,
learning_rate=1.0,
algorithm='SAMME.R')
myboosting.fit(ftrain, y_train)
def extract_feature_image(img, feature_type, feature_coord=None):
"""Extract the haar feature for the current image"""
ii = integral_image(img)
return haar_like_feature(ii, 0, 0, ii.shape[0], ii.shape[1],
feature_type=feature_type,
feature_coord=feature_coord)
from skimage.feature import haar_like_feature_coord
from skimage.feature import draw_haar_like_feature
img = np.ones((6, 6), dtype=np.uint8)
print('IMAGE:')
print(img)
print('IMAGE DIMENSIONS')
print('{} * {}'.format(img.shape[0], img.shape[1]))
img_ii = integral_image(img)
print(img_ii)
coord = (np.array([[(0, 0), (0, 0)], [(0, 1), (0, 1)], [(0, 2), (0, 2)]]))
feature_coord, feature_type = haar_like_feature_coord(width=img.shape[1],
height=img.shape[0],
feature_type="type-3-x")
print('COORDINATES OF EACH FEATURE')
print(type(feature_coord))
print(feature_type)
print(len(feature_type))
print('VALUE OF IMAGE AFTER APPLYING THE FEATURES')
feature = haar_like_feature(img_ii,
0,
0,
img.shape[1],
img.shape[0],
feature_type[0],
feature_coord=feature_coord[0])
print(feature)
print(len(feature))
tr_non_face_labels), len(te_face_data), len(te_non_face_data), len(
te_face_labels), len(te_non_face_labels)
# In[ ]:
tr_data = np.concatenate((tr_face_data, tr_non_face_data))
te_data = np.concatenate((te_face_data, te_non_face_data))
# # Extracting HAAR Features and HAAR Co-ordinates
# In[ ]:
X_train = np.array([
haar_like_feature(integral_image(tr_data[i]),
width=face_dim[0],
height=face_dim[1],
r=0,
c=0) for i in range(len(tr_data))
])
y_train = np.array([+1] * len(tr_face_data) + [-1] * len(tr_non_face_data))
# In[ ]:
X_test = np.array([
haar_like_feature(integral_image(te_data[i]),
width=face_dim[0],
height=face_dim[1],
r=0,
c=0) for i in range(len(te_data))
])
y_test = np.array([+1] * len(te_face_data) + [-1] * len(te_non_face_data))
ii.shape[1],
feature_type=feature_type,
feature_coord=feature_coord)
TOTAL = path + path2
print(path)
img = cv2.imread(path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
feat_coord, feat_type = haar_like_feature_coord(2, 2, feature_types)
features = draw_haar_like_feature(img, 2, 3, 39, 39, feat_coord)
#X = delayed(extract_feature_image(img, feature_types)
#for imgs in img)
#print(X)
#x= extract_feature_image(img,'type-4', feature_coord=None)
img2 = integral_image(img)
feature = haar_like_feature(img, 0, 0, 7, 7, feature_types)
print(len(feature))
print(feature)
#img = cv2.imread('D:\Documents\OPENCV\DB_PLATES\carro (1).jpg')
cv2.namedWindow('Digito', cv2.WINDOW_NORMAL)
cv2.imshow('Digito', features)
cv2.waitKey()
cv2.destroyAllWindows()
import numpy as np
from skimage.transform import integral_image
from skimage.feature import haar_like_feature
img = np.ones((5, 5), dtype=np.uint8)
img_ii = integral_image(img)
feature = haar_like_feature(img_ii, 0, 0, 5, 5, 'type-3-x')
feature
array([-1, -2, -3, -4, -1, -2, -3, -4, -1, -2, -3, -4, -1, -2, -3, -4, -1,
-2, -3, -4, -1, -2, -3, -4, -1, -2, -3, -1, -2, -3, -1, -2, -3, -1,
-2, -1, -2, -1, -2, -1, -1, -1])
from skimage.feature import haar_like_feature_coord
feature_coord, feature_type = zip(
*[haar_like_feature_coord(5, 5, feat_t)
for feat_t in ('type-2-x', 'type-3-x')])
# only select one feature over two
feature_coord = np.concatenate([x[::2] for x in feature_coord])
feature_type = np.concatenate([x[::2] for x in feature_type])
feature = haar_like_feature(img_ii, 0, 0, 5, 5,
feature_type=feature_type,
