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
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
def feature_build(img): from skimage.feature.texture import greycoprops, greycomatrix, local_binary_pattern from skimage.color import rgb2gray img = np.asarray(rgb2gray(img.numpy()), dtype=np.uint8) mat = greycomatrix(img, [1, 2], [0, np.pi/2], levels=4, normed=True, symmetric=True) features = [] if (True): features.append(greycoprops(mat, 'contrast')) features.append(greycoprops(mat, 'dissimilarity')) features.append(greycoprops(mat, 'homogeneity')) #features.append(greycoprops(mat, 'energy')) #features.append(greycoprops(mat, 'correlation')) features = np.concatenate(features) else: radius = 2 features = local_binary_pattern(img, 8*radius, radius, method='default') #'ror', 'uniform', 'var' feature = features.flatten() return torch.tensor(feature).float()
def extract_lbp(image, radius=1.5):
'''
Extract LBP features.
'''
image = Image(data=image.data)
image.convert_to_gray()
image.equalize_clahe()
n_points = 8 * radius
lbp = local_binary_pattern(image.data, n_points, radius)
n_bins = lbp.max() + 1
hist, _ = np.histogram(lbp, normed=True, bins=n_bins, range=(0, n_bins))
hist, _, _ = z_norm_by_feature(hist)
plt.plot(hist)
plt.show()
return lbp
def compute_LBP_rgb(im, mask):
"""
Given a segmented image and a segmentation mask compute LBP and return the corresponding normalized histogram
with 256 bins
:param im: an np array NxMx3 of a segmented image
:param mask: a np array NxMx3 of the segmentation mask
:return: a np array corresponding to the lbp normalized histogram with 256 bins
"""
im_copy = im.copy()
mask_copy = mask.copy()
im_copy = FeatureExtractor.rgb2grayscale(im_copy)
P, R = 8, 1
dim = 2 ** P
mask_copy = mask_copy[:, :, 0].astype(bool)
codes = local_binary_pattern(im_copy, P, R, method="ror")
# hist, _ = np.histogram(codes[mask], bins=np.arange(dim + 1), range=(0, dim))
hist, _ = np.histogram(codes[mask_copy], bins=256, range=(0, 255))
norm_hist = hist / np.sum(hist)
return norm_hist
def getHistogramPeaks(path):
if not os.path.exists(path):
print(path, "does not exist")
return None
print "Handling", os.path.basename(path)
vidcap = cv2.VideoCapture(path)
framenum = 0
peaks = 0
peaks16 = 0
peaks8 = 0
lbppeaks = 0
peakfreq = [0 for _ in range(34)]
peakfreq16 = [0 for _ in range(18)]
peakfreq8 = [0 for _ in range(10)]
lbppeakfreq = [0 for _ in range(28)]
lasthist = [0 for _ in range(32)]
lasthist16 = [0 for _ in range(16)]
lasthist8 = [0 for _ in range(8)]
histdiffs = []
histdiffs16 = []
histdiffs8 = []
success, image = vidcap.read()
while success:
grey = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blurred = cv2.medianBlur(grey, 3)
histogram = cv2.calcHist([blurred], [0], None, [32], [0, 256])
cv2.normalize(histogram, histogram)
hist16 = cv2.calcHist([blurred], [0], None, [16], [0, 256])
cv2.normalize(hist16, hist16)
hist8 = cv2.calcHist([blurred], [0], None, [8], [0, 256])
cv2.normalize(hist8, hist8)
histarray = np.asarray(histogram).ravel()
hist16 = np.asarray(hist16).ravel()
hist8 = np.asarray(hist8).ravel()
if framenum % 5 == 0:
radius = 3
no_points = 8 * radius
lbp = local_binary_pattern(grey, no_points, radius, method='uniform')
cv2.normalize(lbp, lbp)
lbpfreq = itemfreq(lbp.ravel())
lbphist = lbpfreq[:, 1]/sum(lbpfreq[:, 1])
lbphist = np.asarray(lbphist).ravel()
lbphist = np.insert(lbphist, 0, 0)
lbphist = np.append(lbphist, 0)
currentlbppeaks = peakutils.indexes(lbphist, 0.3 * (28 / float(26)), 1) # change dist back to 2 if it worsens
for val in currentlbppeaks:
lbppeakfreq[val] += 1
lbppeaks += len(currentlbppeaks)
minbins = [0 for _ in range(32)]
for idx, hbin in enumerate(histarray):
minbins[idx] = min(hbin, lasthist[idx])
minbins16 = [0 for _ in range(16)]
for idx, hbin in enumerate(hist16):
minbins16[idx] = min(hbin, lasthist16[idx])
minbins8 = [0 for _ in range(8)]
for idx, hbin in enumerate(hist8):
minbins8[idx] = min(hbin, lasthist8[idx])
histarray = np.insert(histarray, 0, 0)
histarray = np.append(histarray, 0)
hist16 = np.insert(hist16, 0, 0)
hist16 = np.append(hist16, 0)
hist8 = np.insert(hist8, 0, 0)
hist8 = np.append(hist8, 0)
currentpeaks = peakutils.indexes(histarray, 0.3 * (34 / float(32)), 1)
curpeaks16 = peakutils.indexes(hist16, 0.3 * (18 / float(16)), 1)
curpeaks8 = peakutils.indexes(hist8, 0.3 * (10 / float(8)), 1)
for val in currentpeaks:
peakfreq[val] += 1
for val in curpeaks16:
peakfreq16[val] += 1
for val in curpeaks8:
peakfreq8[val] += 1
histdiffs.append(1 - (sum(minbins) / float(sum(histarray))))
histdiffs16.append(1 - (sum(minbins16) / float(sum(hist16))))
histdiffs8.append(1 - (sum(minbins8) / float(sum(hist8))))
peaks += len(currentpeaks)
peaks16 += len(curpeaks16)
peaks8 += len(curpeaks8)
lasthist = histarray
lasthist16 = hist16
lasthist8 = hist8
framenum += 1
success, image = vidcap.read()
bias = 0
bias16 = 0
bias8 = 0
lbpbias = 0
if sum(peakfreq) != 0:
#bias = (sum(heapq.nlargest(2, peakfreq)) / float(sum(peakfreq)))
bias = np.var(peakfreq)
bias16 = np.var(peakfreq16)
bias8 = np.var(peakfreq8)
if sum(lbppeakfreq) != 0:
#lbpbias = max(lbppeakfreq) / float(sum(lbppeakfreq))
lbpbias = np.var(lbppeakfreq)
meandiff = np.mean(histdiffs)
meandiff16 = np.mean(histdiffs16)
meandiff8 = np.mean(histdiffs8)
lbpmax = np.argmax(lbppeakfreq)
print(peaks, "histogram peaks (32 bins),", lbppeaks, "lbp peaks")
print(meandiff, "mean diff")
return peaks, peaks16, peaks8, lbppeaks, lbpmax, meandiff, meandiff16, meandiff8, bias, bias16, bias8, lbpbias
cv2.IMREAD_GRAYSCALE)
# get mask and convert them to boolean
pleuraMask = cv2.imread(
inputDir + "/boundary_masks/" + boundaryDataSet + "/pleura/" +
imageName, cv2.IMREAD_GRAYSCALE) > 0
nonPleuraMask = cv2.imread(
inputDir + "/boundary_masks/" + boundaryDataSet + "/non_pleura/" +
imageName, cv2.IMREAD_GRAYSCALE) > 0
# local Binary Pattern (LBP)
radius = 3
nPoints = 8 * radius
# Compute LBP fro the whole input image
lbp = local_binary_pattern(inputImage,
nPoints,
radius,
method='uniform')
nBins = int(lbp.max() + 1)
# split masks into tiles
pleuraTiles, positions = SplitImage(
pleuraMask,
tile_size) # get positions just one here because it is the same
nonPleuraTiles, _ = SplitImage(nonPleuraMask, tile_size)
lbpTiles, _ = SplitImage(lbp, tile_size)
pleuraDataset = ComputeLBPHistograms(positions, lbpTiles, pleuraTiles,
1)
nonPleuraDataset = ComputeLBPHistograms(positions, lbpTiles,
nonPleuraTiles, -1)
def syn_graph_met(m_img, segments, lambda_coff, dist_hist=False):
image = m_img
# init graph by first method, by color distance metric between superpixels.
row = image.shape[0]
col = image.shape[1]
# print(row, col)
segmentsLabel = []
for i in range(row):
for j in range(col):
l = segments[i, j]
if l not in segmentsLabel:
segmentsLabel.append(l)
position = []
ave_position = []
flatten_position = []
for i in segmentsLabel:
pixel_position = []
flatten_pos = []
for m in range(row):
for n in range(col):
if segments[m, n] == i:
pixel_position.append([m, n])
flatten_pos.append(m * col + n)
position.append(pixel_position)
flatten_position.append(flatten_pos)
pixel_position = np.asarray(pixel_position)
ave_position.append(
(sum(pixel_position) / len(pixel_position)).tolist())
# generate average color value and red, green, blue color values
average = []
red_average = []
green_average = []
blue_average = []
for i in range(len(position)):
val = 0
red_val = 0
green_val = 0
blue_val = 0
for j in position[i]:
[m, n] = j
val += 0.299 * image[m, n, 0] + 0.587 * image[
m, n, 1] + 0.114 * image[m, n, 2]
red_val += image[m, n, 0]
green_val += image[m, n, 1]
blue_val += image[m, n, 2]
# val += image[m, n]
average.append(val / len(position[i]))
red_average.append(red_val / len(position[i]))
green_average.append(green_val / len(position[i]))
blue_average.append(blue_val / len(position[i]))
# distance metric: by average value
# average = []
# for i in range(len(position)):
# val = 0
# for j in position[i]:
# [m, n] = j
# val += 0.299*image[m, n, 0] + 0.587*image[m, n, 1] + 0.114*image[m, n, 2]
# # val += image[m, n]
# average.append(val/len(position[i]))
# length = len(position)
# graph = np.zeros((length, length))
# for i in range(length):
# for j in range(length):
# graph[i, j] = abs(average[i] - average[j]) ** 2
graph_time = time.time()
# fully connected
sigma = 255.0
length = len(position)
graph = np.zeros((length, length))
# settings for LBP
radius = 2
n_points = 8 * radius
METHOD = 'uniform'
img, lbp = [], []
for i in range(3):
c_img = image[:, :, i]
c_lbp = local_binary_pattern(c_img, n_points, radius, METHOD)
img.append(c_img)
lbp.append(c_lbp)
for i in range(length):
for j in range(length):
if not dist_hist:
diff = abs(red_average[i] - red_average[j]) + abs(
green_average[i] -
green_average[j]) + abs(blue_average[i] - blue_average[j])
# if lambda_coff:
# dist = LA.norm(np.asarray(ave_position[i]) - np.asarray(ave_position[j]))
# diff = diff + lambda_coff * dist
else:
# reads an input image, color mode
hist1 = hist(flatten_position[i], img, lbp)
hist2 = hist(flatten_position[j], img, lbp)
diff = abs(distance.cityblock(hist1, hist2))
graph[i, j] = diff
# graph[i, j] = math.e ** (-(diff ** 2) / sigma)
# print('graph construction time: ', time.time() - graph_time)
# matrix eigen-decomposition, scipy.sparse.linalg
vals, vectors = np.linalg.eigh(graph)
vals, vectors = np.real(vals), np.real(vectors)
index1, index2, index3 = np.argsort(vals)[0], np.argsort(
vals)[1], np.argsort(vals)[2]
# index1, index2, index3 = np.argsort(vals)[::-1][0], np.argsort(vals)[::-1][1], np.argsort(vals)[::-1][2]
ev1, ev2, ev3 = vectors[:, index1], vectors[:, index2], vectors[:, index3]
return vectors[:, index1], graph
def process(self, arg):
imageName = arg["imageName"]
inputdir = arg["inputdir"]
#boundaryDataSet = arg["boundaryDataSet"]
targetSet = arg["targetSet"]
imagedir = arg["imagedir"]
masksdir = arg["masksdir"]
maskstilesdir = arg["maskstilesdir"]
tile_size = arg["parameters"]["tile_size"]
radius = arg["parameters"]["radius"]
tilepercentage = arg["tilepercentage"]
#df = arg["df"]
print(imageName)
fimage = inputdir + '/' + imagedir + '/' + targetSet + '/' + imageName
fimagmask_pleura_path = inputdir + "/" + masksdir + "/pleura/"
fimagmask_nonpleura_path = inputdir + "/" + masksdir + "/non_pleura/"
"""
fimage = inputdir + imagedir+'/images_cleaned/' + targetSet + '/' + imageName
fimagmask_pleura_path = inputdir + "/boundary_masks/" + boundaryDataSet + "/pleura/"
fimagmask_nonpleura_path = inputdir + "/boundary_masks/" + boundaryDataSet + "/non_pleura/"
"""
#print(fimagmask_pleura_path + imageName)
inputImage = cv2.imread(fimage, cv2.IMREAD_GRAYSCALE)
pleuraMask = cv2.imread(fimagmask_pleura_path + imageName,
cv2.IMREAD_GRAYSCALE) > 0
nonPleuraMask = cv2.imread(fimagmask_nonpleura_path + imageName,
cv2.IMREAD_GRAYSCALE) > 0
# local Binary Pattern (LBP)
#radius = 3
nPoints = 8 * radius
# Compute LBP fro the whole input image
lbp = local_binary_pattern(inputImage,
nPoints,
radius,
method='uniform')
nBins = int(lbp.max() + 1)
# split masks into tiles
pleuraTiles, positions = Util.splitImage(
pleuraMask,
tile_size) # get positions just one here because it is the same
nonPleuraTiles, _ = Util.splitImage(nonPleuraMask, tile_size)
lbpTiles, _ = Util.splitImage(lbp, tile_size)
icc = 1
pleuraDataset = self.computeLBPHistograms(icc, imageName, positions,
lbpTiles, pleuraTiles, nBins,
"pleura", tilepercentage)
icc = len(pleuraDataset) + 1
nonPleuraDataset = self.computeLBPHistograms(icc, imageName, positions,
lbpTiles, nonPleuraTiles,
nBins, "nopleura",
tilepercentage)
return pleuraDataset + nonPleuraDataset