class IdentityDescriptor(LocalDescriptor):
"""
A dummy descriptor, allowing to treat all cases uniformly.
This descriptor returns the local neighborhood, reformatted as
a vector.
"""
name = nstr(b'identity')
def __init__(self):
pass
def compute(self, image):
"""
Returns all the pixels in the region as a vector.
:param image: numpy.array
Image data.
:return: numpy.ndarray 1D
"""
return image.reshape(image.size)
@staticmethod
def dist(self, ft1, ft2, method='euclidean'):
dm = {
'euclidean': lambda x_, y_: norm(x_ - y_),
'cosine': lambda x_, y_: dot(x_, y_) / (norm(x_) * norm(y_))
}
method = method.lower()
if method not in dm:
raise ValueError('Unknown method')
return dm['method'](ft1, ft2)
def _trace_list_to_rec_array(traces):
"""
return a recarray from the trace list. These are seperated into
two arrays due to a weird issue with numpy.sort returning and error
set.
"""
# get the id, starttime, endtime into a recarray
# rec array column names must be native strings due to numpy issue 2407
dtype1 = [(nstr('id'), np.object), (nstr('starttime'), float),
(nstr('endtime'), float)]
dtype2 = [(nstr('data'), np.object), (nstr('stats'), np.object)]
data1 = [(tr.id, tr.stats.starttime.timestamp, tr.stats.endtime.timestamp)
for tr in traces]
data2 = [(tr.data, tr.stats) for tr in traces]
ar1 = np.array(data1, dtype=dtype1) # array of id, starttime, endtime
ar2 = np.array(data2, dtype=dtype2) # array of data, stats objects
#
sort_index = np.argsort(ar1, order=['id', 'starttime'])
return ar1[sort_index], ar2[sort_index]
class LocalDescriptor:
"""
Base class for all local descriptors: given a patch of the image, compute
some feature vector.
"""
__metaclass__ = ABCMeta
name = nstr(b'LocalDescriptor')
@abstractmethod
def compute(self, image):
pass
@staticmethod
def dist(self, ft1, ft2, method=''):
return 0.0
def intg_image(image):
"""
Computes tha integral image following the convention that the
first row and column should be 0s.
:param image: numpy.array
A 2D array (single channel image).
:return:
A 2D array, with shape (image.shape[0]+1, image.shape[1]+1).
"""
if image.ndim != 2:
raise ValueError('The image must be single channel.')
image = np.pad(integral_image(image), ((1,0),(1,0)), mode=nstr(b'constant'), constant_values=0)
return image
# end intg_image
class StatsDescriptor(LocalDescriptor):
"""
A very simple local descriptor based on the first moments
statistics.
"""
name = nstr(b'stats')
def __init__(self, stats=None):
self._statsfn = {
'mean': lambda x_: x_.mean(),
'std': lambda x_: x_.std(),
'kurtosis': lambda x_: kurtosis(x_, axis=None, fisher=True),
'skewness': lambda x_: skew(x_, axis=None, bias=True)
}
if stats is None:
self.stats = ['mean', 'std']
else:
self.stats = [s.lower() for s in stats]
for s in self.stats:
if s not in self._statsfn:
raise ValueError('Unknown summary statistic')
def compute(self, image):
return np.array([self._statsfn[s](image) for s in self.stats])
@staticmethod
def dist(ft1, ft2, method='euclidean'):
"""
Computes the distance between two Stats feature vectors.
:param ft1: a vector of features
:type ft1: numpy.array (1xn)
:param ft2: a vector of features
:type ft2: numpy.array (1xn)
:param method: the method for computing the distance
:type method: string
:return: a distance
:rtype: float
"""
return norm(ft1 - ft2)
def intg_image(image):
"""
Computes tha integral image following the convention that the
first row and column should be 0s.
:param image: numpy.array
A 2D array (single channel image).
:return:
A 2D array, with shape (image.shape[0]+1, image.shape[1]+1).
"""
if image.ndim != 2:
raise ValueError('The image must be single channel.')
image = np.pad(integral_image(image), ((1, 0), (1, 0)),
mode=nstr(b'constant'),
constant_values=0)
return image
# end intg_image
class HaarLikeDescriptor(LocalDescriptor):
"""
Provides local descriptors in terms of respones to a series of Haar-like
features [1]_.
The coding is inspired by HaarLikeFeature class from SimpleCV (www.simplecv.org).
.. [1] http://en.wikipedia.org/wiki/Haar-like_features
"""
name = nstr(b'haar')
def __init__(self, _haars, _norm=True):
"""
Initialize an HaarLikeDescriptors object.
:param _haars: list
a list of feature descriptors. A feature descriptor is a list of points (row, column) in a normalized
coordinate system ((0,0) -> (1,1)) describing the "positive" (black) patches from a Haar-like
feature. All the patches not specified in this list are considered "negative" (white).
The value corresponding to such a feature is the (weighted) sum of pixel intensities covered by
"positive" patches from which the (weighted) sum of pixel intensities covered by "negative" patches
is subtracted.
See some examples at:
- http://www.codeproject.com/Articles/27125/Ultra-Rapid-Object-Detection-in-Computer-Vision-Ap
- http://en.wikipedia.org/wiki/Haar-like_features
Examples of Haar-like features coding:
- a Haar-like feature in which the left side is "positive" (*) and the right side "negative" (.):
+-------+-------+
|*******|.......|
|*******|.......|
|*******|.......|
|*******|.......|
|*******|.......|
|*******|.......|
+-------+-------+
The corresponding coding is: [[(0.0, 0.0), (0.5, 1.0)]].
- a Haar-like feature with diagonal "positive" (*) patches:
+-------+-------+
|*******|.......|
|*******|.......|
|*******|.......|
+-------+-------+
|.......|*******|
|.......|*******|
|.......|*******|
+-------+-------+
The corresponding coding is: [[(0.0, 0.0), (0.5, 0.5)], [(0.5, 0.5), (1.0, 1.0)]].
:param _norm: boolean
Should the features be normalized? (scale-independent?) Default: True
"""
self.haars = _haars
self.nfeats = len(_haars)
self.norm = _norm
# Check that all coordinates are between 0 and 1:
if any([_p < 0.0 or _p > 1.0 for _p in flatten(_haars)]):
raise ValueError("Improper Haar feature specification.")
return
def compute(self, image):
"""
Computes the Haar-like descriptors on an INTEGRAL image.
:param image: numpy.ndarray
This must be the integral image, as computed by skimage.transform.integral_image(),
for example. This format does not contain the first row and column of 0s.
:param _norm: boolean
If True, the features are normalized by half the number of pixels in the image.
:return: numpy.ndarray
a vector of feature values (one per Haar-like feature)
"""
if image.ndim != 2:
raise ValueError("Only grey-level images are supported")
h, w = image.shape
h -= 1
w -= 1
nrm_fact = h * w if self.norm else 1.0
f = np.zeros(self.nfeats, dtype=np.float)
i = 0
S0 = image[h, w] + image[0, 0] - image[h, 0] - image[
0, w] # integral over the image
for hr in self.haars: # for each Haar-like feature
S = 0L # will contain the sum of positive patches in the feature
for p in hr: # for each patch in the current feature
a, b = p # coords of the corners of the patch
row_a = np.int(np.floor(p[0][0] * h))
col_a = np.int(np.floor(p[0][1] * w))
row_b = np.int(np.floor(p[1][0] * h))
col_b = np.int(np.floor(p[1][1] * w))
S += image[row_b, col_b] + image[row_a, col_a] - image[
row_b, col_a] - image[row_a, col_b]
# The final value of the Haar-like feature is the sum of positive patches minus
# the sum of negative patches. Since everything that is not specified as positive
# patch is considered negative, the sum of the negative patches is the total sum
# in the image (corner bottom-right in the integral image) minus the sum of positive
# ones. Hence, the value of the Haar-like feature is 2*S - S0
f[i] = (2.0 * S - S0) / nrm_fact
i += 1
return f
@staticmethod
def dist(ft1, ft2, method='euclidean'):
"""
Computes the distance between two Haar-like feature vectors.
:param ft1: a vector of features
:type ft1: numpy.array (1xn)
:param ft2: a vector of features
:type ft2: numpy.array (1xn)
:param method: the method for computing the distance
:type method: string
:return: a distance
:rtype: float
"""
dm = {
'euclidean': lambda x_, y_: norm(x_ - y_),
'cosine': lambda x_, y_: dot(x_, y_) / (norm(x_) * norm(y_))
}
method = method.lower()
if method not in dm.keys():
raise ValueError('Unknown method')
return dm[method](ft1, ft2)
@staticmethod
def haars1():
"""
Generates a list of Haar-like feature specifications.
:return:
:rtype:
"""
h = [
[[(0.0, 0.0), (0.5, 0.5)], [(0.5, 0.5),
(1.0, 1.0)]], # diagonal blocks
[[(0.0, 0.0), (1.0, 0.5)]], # vertical edge
[[(0.0, 0.0), (0.5, 1.0)]], # horizontal edge
[[(0.0, 0.33), (1.0, 0.67)]], # vertical central band
[[(0.33, 0.0), (0.67, 1.0)]], # horizontal central band
[[(0.25, 0.25), (0.75, 0.75)]]
]
return h
def _read_24_bit_little(fi, length):
""" read a 3 byte int, little endian """
chunk = fi.read(length)
return struct.unpack(nstr('<I'), chunk + b'\x00')[0]
class HOGDescriptor(LocalDescriptor):
"""
Provides local descriptors in terms of histograms of oriented gradients.
"""
name = nstr(b'hog')
def __init__(self, _norient=9, _ppc=(128, 128), _cpb=(4, 4)):
"""
Initialize an HOGDescriptors object. For details see the HOG
descriptor in sciki-image package:
skimage.feature.hog
:param _norient: uint
number of orientations of the gradients
:param _ppc: uint
pixels per cell
:param _cpb: uint
cells per block
"""
self.norient = _norient
self.ppc = _ppc
self.cpb = _cpb
return
def compute(self, image):
"""
Computes HOG on a given image.
:param image: numpy.ndarray
:return: numpy.ndarray
a vector of features
"""
r = hog(image,
pixels_per_cell=self.ppc,
cells_per_block=self.cpb,
visualise=False,
normalise=False)
return r
@staticmethod
def dist(ft1, ft2, method='euclidean'):
"""
Compute the distance between two sets of HOG features. Possible distance types
are:
-Euclidean
-cosine distance: this is not a proper distance!
"""
dm = {
'euclidean': lambda x_, y_: norm(x_ - y_),
'cosine': lambda x_, y_: dot(x_, y_) / (norm(x_) * norm(y_))
}
method = method.lower()
if method not in dm.keys():
raise ValueError('Unknown method')
return dm[method](ft1, ft2)
class HistDescriptor(LocalDescriptor):
"""
Provides local descriptors in terms of histograms of grey levels.
"""
name = nstr(b'hist')
def __init__(self, _interval=(0, 1), _nbins=10):
"""
Initialize an HistDescriptors object: a simple histogram of
grey-levels
:param _interval: tuple
the minimum and maximum values to be accounted for
:param _nbins: uint
number of bins in the histogram
"""
self.interval = _interval
self.nbins = _nbins
return
def compute(self, image):
"""
Computes the histogram on a given image.
:param image: numpy.ndarray
:return: numpy.ndarray
a vector of frequencies
"""
if image.ndim != 2:
raise ValueError("Only grey-level images are supported")
h, _ = np.histogram(image,
normed=True,
bins=self.nbins,
range=self.interval)
return h
@staticmethod
def dist(ft1, ft2, method='bh'):
"""
Computes the distance between two sets of histogram features.
Args:
ft1, ft2: numpy.ndarray (vector)
histograms as returned by compute()
method: string
the method used for computing the distance between the two sets of features:
'kl' - Kullback-Leibler divergence (symmetrized by 0.5*(KL(p,q)+KL(q,p))
'js' - Jensen-Shannon divergence: 0.5*(KL(p,m)+KL(q,m)) where m=(p+q)/2
'bh' - Bhattacharyya distance: -log(sqrt(sum_i (p_i*q_i)))
'ma' - Matusita distance: sqrt(sum_i (sqrt(p_i)-sqrt(q_i))**2)
"""
# distance methods
dm = {
'kl':
lambda x_, y_: 0.5 * (entropy(x_, y_) + entropy(y_, x_)),
'js':
lambda x_, y_: 0.5 *
(entropy(x_, 0.5 * (x_ + y_)) + entropy(y_, 0.5 * (x_ + y_))),
'bh':
lambda x_, y_: -np.log(np.sum(np.sqrt(x_ * y_))),
'ma':
lambda x_, y_: np.sqrt(np.sum((np.sqrt(x_) - np.sqrt(y_))**2))
}
method = method.lower()
if method not in dm.keys():
raise ValueError('Unknown method')
return dm[method](ft1, ft2)
class MFSDescriptor(LocalDescriptor):
"""
Multi-Fractal Dimensions for texture description.
Adapted from IMFRACTAL project at https://github.com/rbaravalle/imfractal
"""
name = nstr(b'fract')
def __init__(self, _nlevels_avg=1, _wsize=15, _niter=1):
"""
Initialize an MFDDescriptors object.
Arguments:
_nlevels_avg: number of levels to be averaged in density computation (uint)
=1: no averaging
_wsize: size of the window for computing descriptors (uint)
_niter: number of iterations
"""
self.nlevels_avg = _nlevels_avg
self.wsize = _wsize
self.niter = _niter
return
def compute(self, im):
"""
Computes MFS over the given image.
Arguments:
im: image (grey-scale) (numpy.ndarray)
Returns:
a vector of descriptors (numpy.array)
"""
## TODO: this needs much polishing to get it run faster!
assert (im.ndim == 2)
# Using [0..255] to denote the intensity profile of the image
grayscale_box = [0, 255]
# Preprocessing: default intensity value of image ranges from 0 to 255
if abs(im).max() < 1:
im = rescale_intensity(im, out_range=(0, 255))
#######################
### Estimating density function of the image
### by solving least squares for D in the equation
### log10(bw) = D*log10(c) + b
r = 1.0 / max(im.shape)
c = np.log10(r * np.arange(start=1, stop=self.nlevels_avg + 1))
bw = np.zeros((self.nlevels_avg, im.shape[0], im.shape[1]),
dtype=np.float32)
bw[0, :, :] = im + 1
def _gauss_krn(size):
""" Returns a normalized 2D gauss kernel array for convolutions """
if size <= 3:
sigma = 1.5
else:
sigma = size / 2.0
y, x = np.mgrid[-(size - 1.0) / 2.0:(size - 1.0) / 2.0 + 1,
-(size - 1.0) / 2.0:(size - 1.0) / 2.0 + 1]
s2 = 2.0 * sigma**2
g = np.exp(-(x**2 + y**2) / s2)
return g / g.sum()
k = 1
if self.nlevels_avg > 1:
bw[1, :, :] = convolve2d(
bw[0, :, :], _gauss_krn(k + 1), mode="full")[1:, 1:] * (
(k + 1)**2)
for k in np.arange(2, self.nlevels_avg):
temp = convolve2d(bw[0, :, :], _gauss_krn(k + 1), mode="full") * (
(k + 1)**2)
if k == 4:
bw[k] = temp[k - 1 - 1:temp.shape[0] - (k / 2),
k - 1 - 1:temp.shape[1] - (k / 2)]
else:
bw[k] = temp[k - 1:temp.shape[0] - (1),
k - 1:temp.shape[1] - (1)]
bw = np.log10(bw)
n1 = np.sum(c**2)
n2 = bw[0] * c[0]
for k in np.arange(1, self.nlevels_avg):
n2 += bw[k] * c[k]
sum3 = np.sum(bw, axis=0)
if self.nlevels_avg > 1:
D = (n2 * self.nlevels_avg -
c.sum() * sum3) / (n1 * self.nlevels_avg - c.sum()**2)
min_D, max_D = 1.0, 4.0
D = grayscale_box[1] * (D - min_D) / (max_D -
min_D) + grayscale_box[0]
else:
D = im
D = D[self.nlevels_avg - 1:D.shape[0] - self.nlevels_avg + 1,
self.nlevels_avg - 1:D.shape[1] - self.nlevels_avg + 1]
IM = np.zeros(D.shape)
gap = np.ceil(
(grayscale_box[1] - grayscale_box[0]) / np.float32(self.wsize))
center = np.zeros(self.wsize)
for k in np.arange(1, self.wsize + 1):
bin_min = (k - 1) * gap
bin_max = k * gap - 1
center[k - 1] = round((bin_min + bin_max) / 2.0)
D = ((D <= bin_max) & (D >= bin_min)).choose(D, center[k - 1])
D = ((D >= bin_max)).choose(D, 0)
D = ((D < 0)).choose(D, 0)
IM = D
# Constructing the filter for approximating log fitting
r = max(IM.shape)
c = np.zeros(self.niter)
c[0] = 1
for k in range(1, self.niter):
c[k] = c[k - 1] / (k + 1)
c = c / sum(c)
# Construct level sets
Idx_IM = np.zeros(IM.shape)
for k in range(0, self.wsize):
IM = (IM == center[k]).choose(IM, k + 1)
Idx_IM = IM
IM = np.zeros(IM.shape)
# Estimate MFS by box-counting
num = np.zeros(self.niter)
MFS = np.zeros(self.wsize)
for k in range(1, self.wsize + 1):
IM = np.zeros(IM.shape)
IM = (Idx_IM == k).choose(Idx_IM, 255 + k)
IM = (IM < 255 + k).choose(IM, 0)
IM = (IM > 0).choose(IM, 1)
temp = max(IM.sum(), 1)
num[0] = np.log10(temp) / np.log10(r)
for j in range(2, self.niter + 1):
mask = np.ones((j, j))
bw = convolve2d(IM, mask, mode="full")[1:, 1:]
indx = np.arange(0, IM.shape[0], j)
indy = np.arange(0, IM.shape[1], j)
bw = bw[np.ix_(indx, indy)]
idx = (bw > 0).sum()
temp = max(idx, 1)
num[j - 1] = np.log10(temp) / np.log10(r / j)
MFS[k - 1] = sum(c * num)
return MFS
@staticmethod
def dist(ft1, ft2, method='euclidean'):
"""
Compute the distance between two sets of multifractal dimension features.
Possible distance types are:
-Euclidean
-cosine distance: this is not a proper distance!
"""
assert (ft1.ndim == ft2.ndim == 1)
assert (ft1.size == ft2.size)
dm = {
'euclidean': lambda x_, y_: norm(x_ - y_),
'cosine': lambda x_, y_: dot(x_, y_) / (norm(x_) * norm(y_))
}
method = method.lower()
if method not in dm.keys():
raise ValueError('Unknown method')
return dm[method](ft1, ft2)
class GaborDescriptor(LocalDescriptor):
"""
Computes Gabor descriptors from an image. These descriptors are the means
and variances of the filter responses obtained by convolving an image with
a bank of Gabor filters.
"""
name = nstr(b'gabor')
def __init__(self,
theta=np.array(
[0.0, np.pi / 4.0, np.pi / 2.0, 3.0 * np.pi / 4.0],
dtype=np.double),
freq=np.array([3.0 / 4.0, 3.0 / 8.0, 3.0 / 16.0],
dtype=np.double),
sigma=np.array([1.0, 2 * np.sqrt(2.0)], dtype=np.double),
normalized=True):
"""
Initialize the Gabor kernels (only real part).
Args:
theta: numpy.ndarray (vector)
Contains the orientations of the filter; defaults to [0, pi/4, pi/2, 3*pi/4].
freq: numpy.ndarray (vector)
The frequencies of the Gabor filter; defaults to [3/4, 3/8, 3/16].
sigma: numpy.ndarray (vector)
The sigma parameter for the Gaussian smoothing filter; defaults to [1, 2*sqrt(2)].
normalized: bool
If true, the kernels are normalized
"""
self.kernels_ = [
np.real(gabor_kernel(frequency=f, theta=t, sigma_x=s, sigma_y=s))
for f in freq for s in sigma for t in theta
]
if normalized:
for k, krn in enumerate(self.kernels_):
self.kernels_[k] = krn / np.sqrt((krn**2).sum())
return
def compute(self, image):
"""
Compute the Gabor descriptors on the given image.
Args:
image: numpy.ndarray (.ndim=2)
Grey scale image.
Returns:
numpy.ndarray (vector) containing the Gabor descriptors (means followed
by the variances of the filter responses)
"""
try:
image = img_as_float(image)
nk = len(self.kernels_)
ft = np.zeros(2 * nk, dtype=np.double)
for k, krn in enumerate(self.kernels_):
flt = nd.convolve(image, krn, mode='wrap')
ft[k] = flt.mean()
ft[k + nk] = flt.var()
except:
print("Error in GaborDescriptor.compute()")
return ft
@staticmethod
def dist(ft1, ft2, method='euclidean'):
"""
Compute the distance between two sets of Gabor features. Possible distance types
are:
-euclidean
-cosine distance: this is not a proper distance!
"""
dm = {
'euclidean': lambda x_, y_: norm(x_ - y_),
'cosine': lambda x_, y_: dot(x_, y_) / (norm(x_) * norm(y_))
}
method = method.lower()
if method not in dm:
raise ValueError('Unknown method')
return dm[method](ft1, ft2)
class LBPDescriptor(LocalDescriptor):
"""
Local Binary Pattern for texture description. A LBP descriptor set is a
histogram of LBPs computed from the image.
"""
name = nstr(b'lbp')
def __init__(self, radius=3, npoints=None, method='uniform'):
"""
Initialize a LBP descriptor set. See skimage.feature.texture.local_binary_pattern
for details on the meaning of parameters.
Args:
radius: int
defaults to 3
npoints: int
defaults to None. If None, npoints is set to 8*radius
method: string
defaults to 'uniform'. Could be 'uniform', 'ror', 'var', 'nri_uniform'
"""
self.radius_ = radius
self.npoints_ = radius * 8 if npoints is None else npoints
self.method_ = method.lower()
self.nhbins_ = self.npoints_ + 2
return
def compute(self, image):
"""
Compute the LBP features. These features are returned as histograms of
LBPs.
"""
try:
lbp = local_binary_pattern(image, self.npoints_, self.radius_,
self.method_)
hist, _ = np.histogram(lbp,
normed=True,
bins=self.nhbins_,
range=(0, self.nhbins_))
except:
print("Error in LBPDescriptor.compute()")
return hist
@staticmethod
def dist(ft1, ft2, method='bh'):
"""
Computes the distance between two sets of LBP features. The features are
assumed to have been computed using the same parameters. The features
are represented as histograms of LBPs.
Args:
ft1, ft2: numpy.ndarray (vector)
histograms of LBPs as returned by compute()
method: string
the method used for computing the distance between the two sets of features:
'kl' - Kullback-Leibler divergence (symmetrized by 0.5*(KL(p,q)+KL(q,p))
'js' - Jensen-Shannon divergence: 0.5*(KL(p,m)+KL(q,m)) where m=(p+q)/2
'bh' - Bhattacharyya distance: -log(sqrt(sum_i (p_i*q_i)))
'ma' - Matusita distance: sqrt(sum_i (sqrt(p_i)-sqrt(q_i))**2)
"""
# distance methods
dm = {
'kl':
lambda x_, y_: 0.5 * (entropy(x_, y_) + entropy(y_, x_)),
'js':
lambda x_, y_: 0.5 *
(entropy(x_, 0.5 * (x_ + y_)) + entropy(y_, 0.5 * (x_ + y_))),
'bh':
lambda x_, y_: -np.log(np.sum(np.sqrt(x_ * y_))),
'ma':
lambda x_, y_: np.sqrt(np.sum((np.sqrt(x_) - np.sqrt(y_))**2))
}
method = method.lower()
if method not in dm.keys():
raise ValueError('Unknown method')
return dm[method](ft1, ft2)
class GLCMDescriptor(LocalDescriptor):
"""
Grey Level Co-occurrence Matrix: the image is decomposed into a number of
non-overlapping regions, and the GLCM features are computed on each of these
regions.
"""
name = nstr(b'glcm')
def __init__(self,
wsize,
dist=0.0,
theta=0.0,
levels=256,
which=None,
symmetric=True,
normed=True):
"""
Initialize GLCM.
Args:
wsize: uint
window size: the image is decomposed into small non-overlapping regions of size
<wsize x wsize> from which the GLCMs are computed. If the last region in a row or
the last row in an image are smaller than the required size, then they are not
used in computing the features.
dist: uint
pair distance
theta: float
pair angle
levels: uint
number of grey levels
which: string
which features to be computed from the GLCM. See the help for
skimage.feature.texture.greycoprops for details
symmetric: bool
consider symmetric pairs?
normed: bool
normalize the co-occurrence matrix, before computing the features?
"""
self.wsize_ = wsize
self.dist_ = dist
self.theta_ = theta
self.levels_ = levels
if which is None:
which = ['dissimilarity', 'correlation']
self.which_feats_ = [w.lower() for w in which]
self.symmetric_ = symmetric
self.normed_ = normed
return
def compute(self, image):
"""
Compute the GLCM features.
"""
assert (image.ndim == 2)
w, h = image.shape
nw = int(w / self.wsize_)
nh = int(h / self.wsize_)
nf = len(self.which_feats_)
ft = np.zeros((nf, nw * nh)) # features will be on rows
k = 0
for x in np.arange(0, nw):
for y in np.arange(0, nh):
x0, y0 = x * self.wsize_, y * self.wsize_
x1, y1 = x0 + self.wsize_, y0 + self.wsize_
glcm = greycomatrix(image[y0:y1, x0:x1], self.dist_,
self.theta_, self.levels_, self.symmetric_,
self.normed_)
ft[:, k] = np.array(
[greycoprops(glcm, f)[0, 0] for f in self.which_feats_])
k += 1
res = {}
k = 0
for f in self.which_feats_:
res[f] = ft[k, :]
k += 1
return res
@staticmethod
def dist(ft1, ft2, method='bh'):
"""
Computes the distance between two sets of GLCM features. The features are
assumed to have been computed using the same parameters. The distance is
based on comparing the distributions of these features.
Args:
ft1, ft2: dict
each dictionary contains for each feature a vector of values computed
from the images
method: string
the method used for computing the distance between the histograms of features:
'kl' - Kullback-Leibler divergence (symmetrized by 0.5*(KL(p,q)+KL(q,p))
'js' - Jensen-Shannon divergence: 0.5*(KL(p,m)+KL(q,m)) where m=(p+q)/2
'bh' - Bhattacharyya distance: -log(sqrt(sum_i (p_i*q_i)))
'ma' - Matusita distance: sqrt(sum_i (sqrt(p_i)-sqrt(q_i))**2)
Returns:
dict
a dictionary with distances computed between pairs of features
"""
# distance methods
dm = {
'kl':
lambda x_, y_: 0.5 * (entropy(x_, y_) + entropy(y_, x_)),
'js':
lambda x_, y_: 0.5 *
(entropy(x_, 0.5 * (x_ + y_)) + entropy(y_, 0.5 * (x_ + y_))),
'bh':
lambda x_, y_: -np.log(np.sum(np.sqrt(x_ * y_))),
'ma':
lambda x_, y_: np.sqrt(np.sum((np.sqrt(x_) - np.sqrt(y_))**2))
}
method = method.lower()
if method not in dm.keys():
raise ValueError('Unknown method')
res = {}
for k in ft1.keys():
if k in ft2.keys():
# build the histograms:
mn = min(ft1[k].min(), ft2[k].min())
mx = max(ft1[k].max(), ft2[k].max())
h1, _ = np.histogram(ft1[k],
normed=True,
bins=10,
range=(mn, mx))
h2, _ = np.histogram(ft2[k],
normed=True,
bins=10,
range=(mn, mx))
res[k] = dm[method](h1, h2)
return res
def _read_24_bit_big(fi, length):
""" read a 3 byte int, big endian """
chunk = fi.read(length)
return struct.unpack(nstr('>I'), b'\x00' + chunk)[0]
def _read_24_bit_little(fi, length):
""" read a 3 byte int, little endian """
chunk = fi.read(length)
return struct.unpack(nstr('<I'), chunk + b'\x00')[0]
def _read_24_bit_big(fi, length):
""" read a 3 byte int, big endian """
chunk = fi.read(length)
return struct.unpack(nstr('>I'), b'\x00' + chunk)[0]