def test_dense():
f = np.arange(280*360).reshape((280,360)) % 25
d16 = surf.dense(f, 16)
d16_s = surf.dense(f, 16, 3.)
d32 = surf.dense(f, 32)
assert len(d16) > len(d32)
assert d16.shape[1] == d32.shape[1]
assert d16.shape[1] == d16_s.shape[1]
def test_dense():
f = np.arange(280 * 360).reshape((280, 360)) % 25
d16 = surf.dense(f, 16)
d16_s = surf.dense(f, 16, 3.)
d32 = surf.dense(f, 32)
assert len(d16) > len(d32)
assert d16.shape[1] == d32.shape[1]
assert d16.shape[1] == d16_s.shape[1]
def classify():
clf = joblib.load('SatisfactionDetector.pkl')
km = joblib.load('SURFcluster.pkl')
alldescriptors = []
image = "3.jpg"
im = mh.imread(image, as_grey=True)
im = im.astype(np.uint8)
alldescriptors.append(surf.dense(im, spacing=16))
# get all descriptors into a single array
concatenated = np.concatenate(alldescriptors)
print concatenated.shape
print('Number of SURF descriptors: {}'.format(len(concatenated)))
concatenated = concatenated[::62]
ifeatures = []
k = 256
c = km.predict(concatenated)
ifeatures.append(np.array([np.sum(c == ci) for ci in range(k)]))
ifeatures = np.array(ifeatures, dtype=float)
features = np.save("TestImage", ifeatures)
print "features are saved into TestImage"
print clf.predict(ifeatures)
def classIs():
clf = joblib.load('SatisfactionDetector.pkl')
km = joblib.load('SURFcluster.pkl')
alldescriptors = []
images = glob('test/*.jpg')
for im in images:
im = mh.imread(im, as_grey=True)
im = im.astype(np.uint8)
alldescriptors.append(surf.dense(im, spacing=16))
# get all descriptors into a single array
concatenated = np.concatenate(alldescriptors)
print('Number of SURF descriptors: {}'.format(len(concatenated)))
concatenated = concatenated[::62]
rfeatures = []
k = 256
for d in concatenated:
c = km.predict(concatenated)
rfeatures.append(np.array([np.sum(c == ci) for ci in range(k)]))
rfeatures = np.array(rfeatures, dtype=float)
features = np.save("TestImages", rfeatures)
print "features are saved into TestImage"
print clf.predict(rfeatures)
def test_dense_scale():
im = luispedro_jpg(True)
surf.dense(im, spacing=32)
s5 = surf.dense(im, spacing=32, scale=5)
s51 = surf.dense(im, spacing=32, scale=5.1)
assert not np.all(s5 == s51)
from sklearn.grid_search import GridSearchCV
C_range = 10.0**np.arange(-4, 3)
grid = GridSearchCV(LogisticRegression(), param_grid={'C': C_range})
clf = Pipeline([('preproc', StandardScaler()), ('classifier', grid)])
cv = cross_validation.KFold(len(features), 5, shuffle=True, random_state=123)
scores = cross_validation.cross_val_score(clf, features, labels, cv=cv)
print('Accuracy: {:.1%}'.format(scores.mean()))
from mahotas.features import surf
image = mh.demos.load('lena')
image = mh.colors.rgb2gray(image, dtype=np.uint8)
descriptors = surf.surf(image, descriptor_only=True)
from mahotas.features import surf
descriptors = surf.dense(image, spacing=16)
alldescriptors = []
for im in images:
im = mh.imread(im, as_grey=True)
im = im.astype(np.uint8)
alldescriptors.append(surf.dense(image, spacing=16))
# get all descriptors into a single array
concatenated = np.concatenate(alldescriptors)
print('Number of descriptors: {}'.format(len(concatenated)))
# use only every 64th vector
concatenated = concatenated[::64]
from sklearn.cluster import KMeans # FIXME CAPITALIZATION
k = 256
km = KMeans(k)
km.fit(concatenated)
cv = cross_validation.KFold(len(features), 5,
shuffle=True, random_state=123)
scores = cross_validation.cross_val_score(
clf, features, labels, cv=cv)
print('Accuracy: {:.1%}'.format(scores.mean()))
from mahotas.features import surf
image = mh.demos.load('lena')
image = mh.colors.rgb2gray(image, dtype=np.uint8)
descriptors = surf.surf(image, descriptor_only=True)
from mahotas.features import surf
descriptors = surf.dense(image, spacing=16)
alldescriptors = []
for im in images:
im = mh.imread(im, as_grey=True)
im = im.astype(np.uint8)
alldescriptors.append(surf.dense(image, spacing=16))
# 하나의 배열에서 모든 디스크립터를 구한다
concatenated = np.concatenate(alldescriptors)
print('Number of descriptors: {}'.format(
len(concatenated)))
# 64번째 벡터를 사용
concatenated = concatenated[::64]
from sklearn.cluster import KMeans # FIXME CAPITALIZATION
k = 256
km = KMeans(k)
km.fit(concatenated)
dog_surf = surf.surf(dog_mh,
nr_octaves=8,
nr_scales=16,
initial_step_size=1,
threshold=0.1,
max_points=54)
fig = plt.figure(figsize=(10, 4))
ax1 = fig.add_subplot(1, 2, 1)
ax1.imshow(surf.show_surf(cat_mh, cat_surf))
ax2 = fig.add_subplot(1, 2, 2)
ax2.imshow(surf.show_surf(dog_mh, dog_surf))
# In[14]:
cat_surf_fds = surf.dense(cat_mh, spacing=10)
dog_surf_fds = surf.dense(dog_mh, spacing=10)
cat_surf_fds.shape
# # Visual Bag of Words model
# ## Engineering features from SURF feature descriptions with clustering
# In[15]:
from sklearn.cluster import KMeans
k = 20
km = KMeans(k, n_init=100, max_iter=100)
surf_fd_features = np.array([cat_surf_fds, dog_surf_fds])
def test_dense_scale():
im = luispedro_jpg(True)
surf.dense(im, spacing=32)
s5 = surf.dense(im, spacing=32, scale=5)
s51 = surf.dense(im, spacing=32, scale=5.1)
assert not np.all(s5 == s51)
def get_features_from_images(img_dir,data_set):
"""
Uses sobel's algorithm for edge detection to get a global feature
and also uses SURF to extract more relevant features per image and
writes it to a file.
"""
print "\nExtracting features from given images..."
img_names = [f for f in os.listdir(img_dir)]
images = [img_dir+ f for f in os.listdir(img_dir)]
features = []
print "\nApplying edginess algorithm and SURF to images"
for im in images:
image = mh.imread(im)
image_sobel = mh.imread(im,as_grey=True)
descriptors = surf.dense(image_sobel,spacing=16)[::32].ravel()
features.append(np.concatenate((mh.features.haralick(image).mean(0),[edginess_sobel(image_sobel)],descriptors),))
features = np.array(features)
print "Writing feature data to file"
f = open(data_set+"_extracted_features.txt","w")
for i in xrange(len(img_names)):
s = str(img_names[i])
for value in features[i]:
s += " "+str(value)
s += "\n"
f.write(s)
f.close()
print "Write completed"
##########################################################################################
############################################ TEST AREA #############################
#img_dir = "Train/Images/"
#image = mh.imread(img_dir+"0a137d3e0fbc21e7dee2efad873610f8.jpg")
#a = mh.features.haralick(image).mean(0)
#print a
#
##r,g,b = image.transpose(2,0,1)
##r12 = mh.gaussian_filter(r,12.)
##g12 = mh.gaussian_filter(g,12.)
##b12 = mh.gaussian_filter(b,12.)
##
##im12 = mh.as_rgb(r12,g12,b12)
##h,w = r.shape
##Y,X = np.mgrid[:h,:w]
##
##Y = Y-h/2
##Y = Y/Y.max()
##X = X-w/2
##X = X/X.max()
##W = np.exp(-2.*(X**2+Y**2))
##
###W = W - W.min()
###W = W / W.ptp()
##
##w = W[:,:,None]
##ringed = mh.stretch(image*w + (1-w)*im12)
#
#image2 = mh.imread(img_dir+"0a137d3e0fbc21e7dee2efad873610f8.jpg",as_grey=True)
#edges = mh.sobel(image2,just_filter=True)
#edges = edges.ravel()
#b = np.sqrt(np.dot(edges,edges))
#print b
#
#descriptors = surf.dense(image2,spacing=16)[::49].ravel()
#descriptors = np.array(descriptors)
#print descriptors
#
#f = np.concatenate((a,[b],descriptors))
#print f
#get_features_from_images(img_dir,"tst")
############################################################################################
def get_features(train, images):
'''
Extract features for train or test images
------------------------------
Parameters
----------
train : Boolean
if Train, get features for train
images : ndarray
1-D array of image filepaths
Returns
----------
haralicks : ndarray
1-D flattened array of haralicks features
lbps : ndarray
1-D flattened array of linear binary patterns
labels : ndarray
1-D array of labels for train images
surf_descriptors : ndarray
1-D flattened array of surf descriptors feature
'''
haralicks = []
lbps = []
labels = []
alldescriptors = []
if train:
k = math.sqrt(22425/2)
path = 'objects/train/'
else:
k = math.sqrt(79727/2)
path = 'objects/test/'
object_dir_file_num = len([name for name in os.listdir(path) if name.endswith('.obj')])
if object_dir_file_num == 5:
haralicks = get_obj(train, 'haralicks')
lbps = get_obj(train, 'lbps')
labels = get_obj(train, 'labels')
surf_descriptors = get_obj(train, 'surfdescriptors')
else:
for i, fname in enumerate(images):
texture = compute_texture(fname)
binary_patt = compute_lbp(fname)
haralicks.append(texture)
lbps.append(binary_patt)
if train:
label = fname.split('/')[2]
labels.append(label)
im = mh.imresize(mh.imread(fname, as_grey=True), (600, 450))
im = im.astype(np.uint8)
# Dense sampling of surf
surf_desc = surf.dense(im, spacing=16)
# regular surf
# surf.surf(im, descriptor_only=True)
print('Image {}: {}'.format(i, surf_desc.shape))
alldescriptors.append(surf_desc)
concatenated = np.concatenate(alldescriptors)
print('Number of descriptors: {}'.format(
len(concatenated)))
concatenated = concatenated[::64]
km = get_kmeans(k, train, concatenated)
surf_descriptors = []
for d in alldescriptors:
c = km.predict(d)
surf_descriptors.append(np.bincount(c, minlength=k))
surf_descriptors = np.array(surf_descriptors, dtype=float)
haralicks = np.array(haralicks)
lbps = np.array(lbps)
labels = np.array(labels)
save_obj(train, 'surfdescriptors', surf_descriptors)
save_obj(train, 'haralicks', haralicks)
save_obj(train, 'lbps', lbps)
save_obj(train, 'labels', labels)
return haralicks, lbps, labels, surf_descriptors
r,g,b = image.transpose((2,0,1))
pixels = 1 * r + 4 * b + 16 * g
hist = np.bincount(pixels.ravel(), minlength=64)
hist = hist.astype(float)
hist = np.log1p(hist)
return hist
for i in range(len(images)):
print "processing image %i of %i" % (i+1, len(images))
labels.append(images[i][:-len('00.jpg')])
im = mh.imread(images[i])
imgrey = mh.colors.rgb2gray(im, dtype=np.uint8)
features.append(np.concatenate([mh.features.haralick(im).ravel(), mh.features.lbp(imgrey, 30, 10).ravel(), colors(im)]))
surfim = mh.imread(images[i], as_grey=True)
surfim = surfim.astype(np.uint8)
alldescriptors.append(surf.dense(surfim, spacing=16))
concatenated = np.concatenate(alldescriptors)
print "fitting k mean clusters for surf descriptors"
km = KMeans(15)
km.fit(concatenated)
print "creating surf features"
sfeatures = []
for d in alldescriptors:
c = km.predict(d)
sfeatures.append(np.array([np.sum(c == ci) for ci in range(15)]))
features = np.array(features)
sfeatures = np.array(sfeatures, dtype=float)
features = np.concatenate((features, sfeatures), axis=1)
labels = np.array(labels)
