def setColorStats(self):
replineCenters = self.getReplineCenters()
LMean = 0
aMean = 0
bMean = 0
numberOfCobs = 0
for cob in self.cobs:
LMean += self.cobs[cob].averageLab["L"]
aMean += self.cobs[cob].averageLab["a"]
bMean += self.cobs[cob].averageLab["b"]
numberOfCobs += 1
LMean = LMean / float(numberOfCobs)
aMean = aMean / float(numberOfCobs)
bMean = bMean / float(numberOfCobs)
rgb1 = Kernel.HunterLabToRGB(replineCenters[0][0],
replineCenters[0][1],
replineCenters[0][2])
rgb2 = Kernel.HunterLabToRGB(replineCenters[1][0],
replineCenters[1][1],
replineCenters[1][2])
self.averageRGB["R"], self.averageRGB["G"], self.averageRGB[
"B"] = Kernel.HunterLabToRGB(LMean, aMean, bMean)
self.averageLab["L"] = LMean
self.averageLab["a"] = aMean
self.averageLab["b"] = bMean
self.centers = {"R1": rgb1["R"], "R2": rgb2["R"], "G1": rgb1["G"], "G2": rgb2["G"], "B1": rgb1["B"], "B2": rgb2["B"],
"L1": replineCenters[0][0], "L2": replineCenters[1][0], "a1": replineCenters[0][1], "a2": replineCenters[1][1], "b1": replineCenters[0][2], "b2": replineCenters[1][2]}
clusterDifference = (abs(replineCenters[0][0] - replineCenters[1][0]) +
abs(replineCenters[0][1] - replineCenters[1][1]) +
abs(replineCenters[0][2] - replineCenters[1][2]))
def showscatterplot(self, s=80, closepreviousplot=True):
if len(self.coblist) == 1:
self.coblist[0].showscatterplot(s, closepreviousplot)
else:
lablists = Kernel.threeTupleToThreeLists(self.allkernelclusters)
if closepreviousplot == True:
plt.close(1)
plot = plt.figure()
axes = plot.add_subplot(111, projection='3d')
llist = lablists[0]
alist = lablists[1]
blist = lablists[2]
for l, a, b in zip(llist, alist, blist):
R, G, B = Kernel.HunterLabToRGB(l, a, b, normalized=True)
axes.scatter(l, a, b, color=[R, G, B], marker='s', s=s)
axes.set_xlabel('L')
axes.set_ylabel('a')
axes.set_zlabel('b')
totalsize = 0
for cluster in self.clusters:
totalsize += cluster[0]
for cluster in self.clusters:
addedsize = int(s * (cluster[0] / totalsize))
s += addedsize
Kernel.addpoints(cluster[1], axes, marker="o", color="g", s=s)
plt.title(self.name)
plt.ion()
plt.show()
return axes
def __init__(self, kernels, show=False):
'''
TEST THIS
'''
self.name = ''
self.averageRGB = {"R": 0, "G": 0, "B": 0}
self.averageLab = {"L": 0, "a": 0, "b": 0}
self.kernelList = kernels
self.numberOfKernels = len(self.kernelList)
LMean = 0
aMean = 0
bMean = 0
#The below code will calculate the 2SDMean wrong!
for kernel in self.kernelList:
LMean += kernel.LabDict["L2SDMean"]
aMean += kernel.LabDict["a2SDMean"]
bMean += kernel.LabDict["b2SDMean"]
LMean = LMean / float(self.numberOfKernels)
aMean = aMean / float(self.numberOfKernels)
bMean = bMean / float(self.numberOfKernels)
# the above code is wrong!
rgb = Kernel.HunterLabToRGB(LMean, aMean, bMean)
self.averageRGB["R"] = rgb["R"]
self.averageRGB["G"] = rgb["G"]
self.averageRGB["B"] = rgb["B"]
self.averageLab["L"] = LMean
self.averageLab["a"] = aMean
self.averageLab["b"] = bMean
self.KernelsCenters = []
self.setKernelsCenters()
def dbscan(self, eps=.5, plot=False):
if len(self.coblist) > 1:
pixlist = []
totalnumkernels = 0
for cob in self.coblist:
for kernel in cob.kernellist:
pixlist.extend(kernel.pixellist)
totalnumkernels += 1
X = Kernel.np.array(pixlist)
density = eps
numberofpixels = len(pixlist)
db = Kernel.DBSCAN(eps=density).fit(X)
core_samples_mask = Kernel.np.zeros_like(db.labels_, dtype=bool)
core_samples_mask[db.core_sample_indices_] = True
labels = db.labels_
n_clusters_ = len(set(labels)) - (1 if -1 in labels else 0)
unique_labels = set(labels)
colors = []
for k in unique_labels:
class_member_mask = (labels == k)
xyz = X[class_member_mask & core_samples_mask]
llist, alist, blist = xyz[:, 0], xyz[:, 1], xyz[:, 2]
if len(llist) >= numberofpixels / 100:
lmean = llist.mean()
amean = alist.mean()
bmean = blist.mean()
self.clusters.append([size, [lmean, amean, bmean]])
r, g, b = Kernel.HunterLabToRGB(lmean, amean, bmean)
colors.append([r / 255.0, g / 255.0, b / 255.0])
else:
colors.append('k')
if plot is True:
graph = plt.figure()
ax = graph.add_subplot(111, projection='3d')
for k, col in zip(unique_labels, colors):
if k == -1:
col = 'k'
class_member_mask = (labels == k)
xyz = X[class_member_mask & core_samples_mask]
if len(xyz[:, 0]) >= numberofpixels / 100:
print len(xyz[:, 0])
ax.scatter(xyz[:, 0], xyz[:, 1], xyz[:, 2], c=col)
xyz = X[class_member_mask & ~core_samples_mask]
ax.scatter(xyz[:, 0],
xyz[:, 1],
xyz[:, 2],
c=col,
marker='.')
ax.set_xlabel('L')
ax.set_ylabel('a')
ax.set_zlabel('b')
plt.title('Estimated number of clusters: %d' % n_clusters_)
plt.ion()
plt.show()
return db
elif len(self.coblist) == 1:
self.clusters = self.coblist[0].clusters
def showscatterplot(self, s=20, closepreviousplot=True):
'''
creates a 3d scatter plot whose points are either pixels from all the kernels in this cob,
or centers from the kmean clusters of each kernel in this cob.
'''
if self.type == 'pixels':
pixels = []
for kernel in self.kernellist:
pixels.extend(kernel.pixellist)
lablists = Kernel.threeTupleToThreeLists(pixels)
else:
lablists = Kernel.threeTupleToThreeLists(self.kernelcenters)
if closepreviousplot == True:
plt.close(1)
plot = plt.figure()
axes = plot.add_subplot(111, projection='3d')
llist = lablists[0]
alist = lablists[1]
blist = lablists[2]
for l, a, b in zip(llist, alist, blist):
R, G, B = Kernel.HunterLabToRGB(l, a, b, normalized=True)
axes.scatter(l, a, b, color=[R, G, B], marker='s', s=s)
axes.set_xlabel('L')
axes.set_ylabel('a')
axes.set_zlabel('b')
totalsize = 0
for cluster in self.clusters:
totalsize += cluster[0]
for cluster in self.clusters:
addedsize = int(s * (cluster[0] / totalsize))
s += addedsize
Kernel.addpoints(cluster[1], axes, marker="o", color="g", s=s)
plt.title(self.name)
plt.ion()
plt.show()
return axes
