Skip to content

GitLab

Commit d9b6effc authored by JosefBrandt's avatar JosefBrandt
Browse files
Options

Segmentation now running on sub-components, FuzzyClustering added 

The segmentation now takes considerably less memory and can run on larger images.

(Optional) fuzzy clustering of seedpoints per component reduces over-segmentation.
parent dd71babf
Hide whitespace changes
Inline Side-by-side
Showing with 339 additions and 246 deletions
detectionview.py
View file @ d9b6effc
......@@ -312,6 +312,7 @@ class ParticleDetectionView(QtWidgets.QWidget):
self.showseedpoints.stateChanged.connect(self.imglabel.changeSeedDisplay)
self.showseedpoints.setChecked(True)
self.setImageCenter()
group = QtWidgets.QGroupBox("Detection settings", self)
grid = QtWidgets.QGridLayout()
self.parameters = []
......@@ -327,6 +328,7 @@ class ParticleDetectionView(QtWidgets.QWidget):
colstretch = 2
if p.dtype == np.bool:
paramui = QtWidgets.QCheckBox(p.helptext, self)
paramui.stateChanged.connect(self.autoUpdateIfDesired)
paramui.setChecked(p.value)
valuefunc = makeValueLambda(paramui.isChecked)
colstretch = 2
......@@ -346,6 +348,7 @@ class ParticleDetectionView(QtWidgets.QWidget):
paramui.setSingleStep(p.stepsize)
paramui.setValue(p.value)
paramui.setMinimumWidth(70)
paramui.valueChanged.connect(self.autoUpdateIfDesired)
valuefunc = makeValueLambda(paramui.value)
elif p.dtype is None:
label = QtWidgets.QLabel(p.helptext, self)
......@@ -409,7 +412,7 @@ class ParticleDetectionView(QtWidgets.QWidget):
self.slider.setOrientation(QtCore.Qt.Horizontal)
self.slider.sliderMoved.connect(self.imglabel.resetAlpha)
vbox.addWidget(self.slider)
self.autoUpdateCheckBox = QtWidgets.QCheckBox('Auto-update detection')
self.autoUpdateCheckBox.setMaximumWidth(200)
self.autoUpdateCheckBox.setChecked(True)
......@@ -538,9 +541,15 @@ class ParticleDetectionView(QtWidgets.QWidget):
if self.drag:
self.lastcenter = self.lastmove
self.drag = False
if self.autoUpdateCheckBox.isChecked():
self.detectShow(None)
self.autoUpdateIfDesired()
def autoUpdateIfDesired(self):
try:
if self.autoUpdateCheckBox.isChecked():
self.detectShow(None)
except: #the method is already called when automatically setting default parameters, which causes various errors because initialization is not yet finished...
pass
def setDataSet(self, ds):
self.dataset = ds
self.updateImageSeeds()
......
segmentation.py
View file @ d9b6effc
......@@ -26,6 +26,7 @@ from scipy.interpolate import InterpolatedUnivariateSpline
from scipy import ndimage as ndi
from skimage.feature import peak_local_max
from skimage.morphology import watershed
import skfuzzy as fuzz
import random
def closeHolesOfSubImage(subimg):
......@@ -39,6 +40,11 @@ def closeHolesOfSubImage(subimg):
return im_out[1:-1, 1:-1]
class Parameter(object):
"""
A Parameter for driving the image segmentation. All Parameters are initialized in the Segmentation Class.
The DetectionView-Widget reads these parameters and creates and connects the necessary items in the ui.
:return:
"""
def __init__(self, name, dtype, value=None, minval=None, maxval=None,
decimals=0, stepsize=1, helptext=None, show=False, linkedParameter=None):
self.name = name
......@@ -77,6 +83,7 @@ class Segmentation(object):
'maxparticlearea': 100000,
'minparticledistance': 20,
'closeBackground': False,
'fuzzycluster': False,
'measurefrac': 1,
'compactness': 0.0,
'seedRad': 3}
......@@ -99,7 +106,7 @@ class Segmentation(object):
Parameter("activateLowThresh", np.bool, self.detectParams['activateLowThresh'], helptext="activate lower threshold", show=False, linkedParameter='lowThresh'),
Parameter("lowThresh", float, self.detectParams['lowThresh'], .01, .9, 2, .02, helptext="Lower threshold", show=True),
Parameter("activateUpThresh", np.bool, self.detectParams['activateUpThresh'], helptext="activate upper threshold", show=False, linkedParameter='upThresh'),
Parameter("upThresh", float, self.detectParams['upThresh'], .01, 1.0, 2, .02, helptext="Upper threshold", show=True),
Parameter("upThresh", float, self.detectParams['upThresh'], .01, 1.0, 2, .02, helptext="Upper threshold", show=False),
Parameter("maxholebrightness", float, self.detectParams['maxholebrightness'], 0, 1, 2, 0.02, helptext="Close holes brighter than..", show = True),
Parameter("minparticlearea", int, self.detectParams['minparticlearea'], 1, 1000, 0, 50, helptext="Min. particle pixel area", show=False),
Parameter("enableMaxArea", np.bool, self.detectParams['enableMaxArea'], helptext="enable filtering for maximal pixel area", show=False, linkedParameter='maxparticlearea'),
......@@ -107,13 +114,14 @@ class Segmentation(object):
Parameter("minparticledistance", int, self.detectParams['minparticledistance'], 5, 1000, 0, 5, helptext="Min. distance between particles", show=False),
Parameter("measurefrac", float, self.detectParams['measurefrac'], 0, 1, 2, stepsize = 0.05, helptext="measure fraction of particles", show=False),
Parameter("closeBackground", np.bool, self.detectParams['closeBackground'], helptext="close holes in sure background", show=False),
Parameter("fuzzycluster", np.bool, self.detectParams['fuzzycluster'], helptext='Enable Fuzzy Clustering', show=False),
Parameter("sure_fg", None, helptext="Show sure foreground", show=True),
Parameter("compactness", float, self.detectParams['compactness'], 0, 1, 2, 0.05, helptext="watershed compactness", show=False),
Parameter("watershed", None, helptext="Show watershed markers", show=True),
]
# make each parameter accessible via self.name
# the variables are defined as properties and because of how the local context
# in for loops works the actural setter and getter functions are defined inside
# in for loops works the actual setter and getter functions are defined inside
# a separate contex in a local function
def makeGetter(p):
return lambda : p.value
......@@ -126,164 +134,13 @@ class Segmentation(object):
self.__dict__[p.name] = property(makeGetter(p), makeSetter(p))
self.parlist = parlist
def setParameters(self, **kwargs):
for key in kwargs:
self.__dict__[key] = kwargs[key]
def convert2Gray(self, img):
gray = cv2.cvtColor(img,cv2.COLOR_RGB2GRAY)
return gray
def calculateHist(self, gray):
hist = cv2.calcHist([gray],[0],None,[256],[0,256])
return hist
def calculateHistFunction(self, points):
t = np.linspace(0,1,800)
x0 = np.concatenate(([-1.],points[:,0],[256.]))
y0 = np.concatenate(([0.],points[:,1],[255.]))
t0 = np.concatenate(([0.],np.cumsum(np.sqrt(np.diff(x0)**2+np.diff(y0)**2))))
t0 /= t0[-1]
fx = InterpolatedUnivariateSpline(t0, x0, k=3)
fy = InterpolatedUnivariateSpline(t0, y0, k=3)
x = fx(t)
y = fy(t)
arr = np.zeros(256, dtype=np.uint8)
xi = np.arange(256)
ind = np.searchsorted(xi, x)
arr[ind[ind<256]] = y[ind<256]
arr[xi>points[:,0].max()] = 255
arr[xi<points[:,0].min()] = 0.
arr[arr>255] = 255.
arr[arr<0] = 0.
return xi, arr
def closeHoles(self, thresh):
n, labels, stats, centroids = cv2.connectedComponentsWithStats(thresh, 8, cv2.CV_32S)
newthresh = np.zeros_like(thresh)
for label in range(1, n):
up = stats[label, cv2.CC_STAT_TOP]
left = stats[label, cv2.CC_STAT_LEFT]
width = stats[label, cv2.CC_STAT_WIDTH]
height = stats[label, cv2.CC_STAT_HEIGHT]
subimg = np.uint8(255 * (labels[up:(up+height), left:(left+width)] == label))
newthresh[up:(up+height), left:(left+width)] += closeHolesOfSubImage(subimg)
return newthresh
def closeBrightHoles(self, thresh, grayimage, maxbrightness):
n, labels, stats, centroids = cv2.connectedComponentsWithStats(thresh, 8, cv2.CV_32S)
maxbrightness = np.uint8(maxbrightness * 255)
print('num comps in brightHoles:', n)
for label in range(1, n):
up = stats[label, cv2.CC_STAT_TOP]
left = stats[label, cv2.CC_STAT_LEFT]
width = stats[label, cv2.CC_STAT_WIDTH]
height = stats[label, cv2.CC_STAT_HEIGHT]
subimg = np.uint8(255 * (labels[up:(up+height), left:(left+width)] == label))
# Add padding to TrehsholdImage
subimg = cv2.copyMakeBorder(subimg, 1, 1, 1, 1, 0)
# Copy the thresholded image.
im_floodfill = subimg.copy()
# Mask used to flood filling.
# Notice the size needs to be 2 pixels than the image.
h, w = subimg.shape[:2]
mask = np.zeros((h+2, w+2), np.uint8)
# Floodfill from point (0, 0)
cv2.floodFill(im_floodfill, mask, (0,0), 255);
indices = np.where(im_floodfill == 0)[0]
if len(indices) > 0:
if np.mean(grayimage[indices[0]]) > maxbrightness:
# close hole and add closed image to thresh:
im_floodfill_inv = cv2.bitwise_not(im_floodfill)
# Combine the two images to get the foreground.
im_out = subimg | im_floodfill_inv
thresh[up:(up+height), left:(left+width)] += im_out[1:-1, 1:-1]
return thresh
def getEdgeBorders(self, image):
edges = abs(cv2.Laplacian(image, cv2.CV_64F))
edges = cv2.blur(edges, (5, 5))
edges = edges**0.6
edges = edges/edges.max()
return edges
def filterThresholdByAreas(self, thresh, minarea, maxarea):
newthresh = np.zeros_like(thresh)
n, labels, stats, centroids = cv2.connectedComponentsWithStats(thresh, 8, cv2.CV_32S)
print('num comps:', n)
for label in range(1, n):
area = stats[label, cv2.CC_STAT_AREA]
if minarea < area < maxarea:
up = stats[label, cv2.CC_STAT_TOP]
left = stats[label, cv2.CC_STAT_LEFT]
width = stats[label, cv2.CC_STAT_WIDTH]
height = stats[label, cv2.CC_STAT_HEIGHT]
subthresh = np.uint8(255 * (labels[up:(up+height), left:(left+width)] == label))
newthresh[up:(up+height), left:(left+width)] += subthresh
return newthresh
def getSureForeground(self, thresh, mindistance):
sure_fg = np.zeros_like(thresh)
n, labels, stats, centroids = cv2.connectedComponentsWithStats(thresh, 8, cv2.CV_32S)
for label in range(1, n):
up = stats[label, cv2.CC_STAT_TOP]
left = stats[label, cv2.CC_STAT_LEFT]
width = stats[label, cv2.CC_STAT_WIDTH]
height = stats[label, cv2.CC_STAT_HEIGHT]
subimg = np.uint8(255 * (labels[up:(up+height), left:(left+width)] == label))
subdist = cv2.distanceTransform(subimg, cv2.DIST_L2,3)
subfg = np.uint8(peak_local_max(subdist, mindistance, indices = False))
# if subfg.max() > 0 and random() < self.measurefrac: #i.e., at least one maximum value was added
# sure_fg[up:(up+height), left:(left+width)] += subfg
#
# elif random() < self.measurefrac:
# #simply get maximum of subdist
# submax = np.where(subdist == subdist.max())
# sure_fg[up+submax[0][0], left+submax[1][0]] = 1
if subfg.max() > 0: #i.e., at least one maximum value was added
sure_fg[up:(up+height), left:(left+width)] += subfg
else:
#simply get maximum of subdist
submax = np.where(subdist == subdist.max())
sure_fg[up+submax[0][0], left+submax[1][0]] = 1
sure_fg = cv2.dilate(sure_fg, np.ones((3, 3)))
return sure_fg
def getMeasurementPoints(self, binParticle, numPoints=1):
binParticle = cv2.copyMakeBorder(binParticle, 1, 1, 1, 1, 0)
dist = cv2.distanceTransform(np.uint8(binParticle), cv2.DIST_L2,3)
ind = np.argmax(dist)
y = [ind//dist.shape[1]-1]
x = [ind%dist.shape[1]-1]
for i in range(numPoints-1):
binParticle.flat[ind] = 0
dist = cv2.distanceTransform(np.uint8(binParticle), cv2.DIST_L2,3)
ind = np.argmax(dist)
y.append(ind//dist.shape[1]-1)
x.append(ind%dist.shape[1]-1)
return y, x
def apply2Image(self, img, seedpoints, deletepoints, seedradius, dataset, return_step=None):
"""
Takes an image with seedpoints and seeddeletepoints and runs segmentation on it.
:return:
"""
t0 = time()
# convert to gray image and do histrogram normalization
gray = self.convert2Gray(img)
print("gray")
......@@ -356,6 +213,12 @@ class Segmentation(object):
thresh = self.closeBrightHoles(thresh, blur, self.maxholebrightness)
print("closed holes")
# modify thresh with seedpoints and deletepoints
for p in np.int32(seedpoints):
cv2.circle(thresh, tuple([p[0], p[1]]), int(p[2]), 255, -1)
for p in np.int32(deletepoints):
cv2.circle(thresh, tuple([p[0], p[1]]), int(p[2]), 0, -1)
if return_step=='maxholebrightness': return thresh, 0
if self.cancelcomputation:
return None, None, None
......@@ -364,103 +227,119 @@ class Segmentation(object):
maxArea = self.maxparticlearea
else:
maxArea = np.inf
thresh = self.filterThresholdByAreas(thresh, self.minparticlearea, maxArea)
print('filter threshold by areas')
if return_step == 'maxparticlearea': return thresh, 0
if self.cancelcomputation:
return None, None, None
####get sure_fg
##get sure_fg
'''the peak_local_max function takes the min distance between peaks. Unfortunately, that means that individual
particles smaller than that distance are consequently disregarded. Hence, we need a connectec_components approach'''
n, labels, stats, centroids = cv2.connectedComponentsWithStats(thresh, 8, cv2.CV_32S)
del thresh
sure_fg = self.getSureForeground(thresh, self.minparticledistance)
measurementPoints = {}
finalcontours = []
particleIndex = 0
sure_bg = cv2.dilate(thresh, np.ones((5, 5)), iterations = 1)
if self.closeBackground:
sure_bg = self.closeHoles(sure_bg)
if return_step == "sure_fg":
preview_surefg = np.zeros(img.shape[:2])
preview_surebg = np.zeros(img.shape[:2])
elif return_step is None:
previewImage = None
else:
previewImage = np.zeros(img.shape[:2])
# modify sure_fg and sure_bg with seedpoints and deletepoints
for p in np.int32(seedpoints):
cv2.circle(sure_fg, tuple([p[0], p[1]]), int(p[2]), 1, -1)
cv2.circle(sure_bg, tuple([p[0], p[1]]), int(p[2]), 1, -1)
for p in np.int32(deletepoints):
cv2.circle(sure_fg, tuple([p[0], p[1]]), int(p[2]), 0, -1)
cv2.circle(sure_bg, tuple([p[0], p[1]]), int(p[2]), 0, -1)
print("sure_fg, sure_bg")
if self.cancelcomputation:
return None, None, None
for label in range(1, n):
area = stats[label, cv2.CC_STAT_AREA]
if self.minparticlearea < area < maxArea:
up = stats[label, cv2.CC_STAT_TOP]
left = stats[label, cv2.CC_STAT_LEFT]
width = stats[label, cv2.CC_STAT_WIDTH]
height = stats[label, cv2.CC_STAT_HEIGHT]
subthresh = np.uint8(255 * (labels[up:(up+height), left:(left+width)] == label))
subdist = cv2.distanceTransform(subthresh, cv2.DIST_L2,3)
sure_fg = self.getSureForeground(subthresh, subdist, self.minparticledistance)
sure_bg = cv2.dilate(subthresh, np.ones((5, 5)), iterations = 1)
if self.closeBackground:
sure_bg = self.closeHoles(sure_bg)
unknown = cv2.subtract(sure_bg, sure_fg)
ret, markers = cv2.connectedComponents(sure_fg)
markers = markers+1
markers[unknown==255] = 0
print("connectedComponents")
if self.cancelcomputation:
return None, None, None
if return_step=="sure_fg":
img = np.zeros_like(sure_fg)
img[np.nonzero(sure_fg)] |= 1 #dilation of sure_fg is included in self.getSureForeground
img[np.nonzero(sure_bg)] |= 2
return img, 1
dist_transform = cv2.distanceTransform(thresh, cv2.DIST_L2,5)
print("distanceTransform")
if self.cancelcomputation:
return None, None, None
twatershed = time()
# modify sure_fg and sure_bg with seedpoints and deletepoints
for p in np.int32(seedpoints):
cv2.circle(sure_fg, tuple([p[0]-left, p[1]-up]), int(p[2]), 1, -1)
cv2.circle(sure_bg, tuple([p[0]-left, p[1]-up]), int(p[2]), 1, -1)
for p in np.int32(deletepoints):
cv2.circle(sure_fg, tuple([p[0]-left, p[1]-up]), int(p[2]), 0, -1)
cv2.circle(sure_bg, tuple([p[0]-left, p[1]-up]), int(p[2]), 0, -1)
markers = ndi.label(sure_fg)[0]
markers = watershed(-dist_transform, markers, mask=sure_bg, compactness = self.compactness, watershed_line = True) #labels = 0 for background, 1... for particles
if self.cancelcomputation:
return None, None, None
print("watershed, elapsed time:", time()-twatershed, "seconds")
if self.cancelcomputation:
return None, None, None
if return_step=="watershed":
return np.uint8(255*(markers!=0)), 0
tcont = time()
if cv2.__version__ > '3.5':
contours, hierarchy = cv2.findContours(markers, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
else:
temp, contours, hierarchy = cv2.findContours(markers, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
print("contour detection, elapsed time:", time()-tcont, "seconds")
if self.cancelcomputation:
return None, None, None
tstats = time()
measurementPoints = {}
tmpcontours = [contours[i] for i in range(len(contours)) if hierarchy[0,i,3]<0]
contours = []
particleIndex = 0
if return_step=="sure_fg":
preview_surefg = self.addToPreviewImage(sure_fg, up, left, preview_surefg)
preview_surebg = self.addToPreviewImage(sure_bg, up, left, preview_surebg)
continue
unknown = cv2.subtract(sure_bg, sure_fg)
ret, markers = cv2.connectedComponents(sure_fg)
markers = markers+1
markers[unknown==255] = 0
for cnt in tmpcontours:
label = markers[cnt[0,0,1],cnt[0,0,0]]
if label==0:
continue
markers = ndi.label(sure_fg)[0]
markers = watershed(-subdist, markers, mask=sure_bg, compactness = self.compactness, watershed_line = True) #labels = 0 for background, 1... for particles
x0, x1 = cnt[:,0,0].min(), cnt[:,0,0].max()
y0, y1 = cnt[:,0,1].min(), cnt[:,0,1].max()
subimg = (markers[y0:y1+1,x0:x1+1]).copy()
subimg[subimg!=label] = 0
y, x = self.getMeasurementPoints(subimg)
contours.append(cnt)
measurementPoints[particleIndex] = []
for index in range(0, len(x)):
newMeasPoint = MeasurementPoint(particleIndex, x[index] + x0, y[index] + y0)
measurementPoints[particleIndex].append(newMeasPoint)
particleIndex += 1
print("contour stats, elapsed time:", time()-tstats, "seconds")
if self.cancelcomputation:
return None, None, None
if return_step is not None:
raise NotImplementedError(f"this particular return_step: {return_step} is not implemented yet")
if return_step=="watershed":
previewImage = self.addToPreviewImage(markers, up, left, previewImage)
continue
if cv2.__version__ > '3.5':
contours, hierarchy = cv2.findContours(markers, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
else:
temp, contours, hierarchy = cv2.findContours(markers, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
if self.cancelcomputation:
return None, None, None
tmpcontours = [contours[i] for i in range(len(contours)) if hierarchy[0,i,3]<0]
for cnt in tmpcontours:
if cv2.contourArea(cnt) >= self.minparticlearea:
label = markers[cnt[0,0,1],cnt[0,0,0]]
if label==0:
continue
x0, x1 = cnt[:,0,0].min(), cnt[:,0,0].max()
y0, y1 = cnt[:,0,1].min(), cnt[:,0,1].max()
subimg = (markers[y0:y1+1,x0:x1+1]).copy()
subimg[subimg!=label] = 0
y, x = self.getMeasurementPoints(subimg)
for i in range(len(cnt)):
cnt[i][0][0] += left
cnt[i][0][1] += up
finalcontours.append(cnt)
measurementPoints[particleIndex] = []
for index in range(0, len(x)):
newMeasPoint = MeasurementPoint(particleIndex, x[index] + x0 + left, y[index] + y0 + up)
measurementPoints[particleIndex].append(newMeasPoint)
particleIndex += 1
if return_step == 'sure_fg':
img = np.zeros_like(preview_surefg)
img[np.nonzero(preview_surefg)] |= 1
img[np.nonzero(preview_surebg)] |= 2
return img, 1
elif return_step == 'watershed':
return np.uint8(255*(previewImage!=0)), 0
tf = time()
print("particle detection took:", tf-t0, "seconds")
elif return_step is not None:
raise NotImplementedError(f"this particular return_step: {return_step} is not implemented yet")
print("particle detection took:", time()-t0, "seconds")
if self.measurefrac < 1.0:
nMeasurementsDesired = int(np.round(self.measurefrac * len(measurementPoints)))
......@@ -470,5 +349,210 @@ class Segmentation(object):
for index in partIndicesToMeasure:
newMeasPoints[index] = measurementPoints[index]
measurementPoints = newMeasPoints
total_time = time()-t0
print('segmentation took', total_time, 'seconds')
return measurementPoints, finalcontours
def addToPreviewImage(self, subimg, up, left, previewImage):
"""
Adds a subimage at given position to the previewimage
:return:
"""
height, width = subimg.shape[0], subimg.shape[1]
previewImage[up:up+height, left:left+width] += subimg
previewImage = np.array(previewImage, dtype = np.int32)
return previewImage
def setParameters(self, **kwargs):
"""
Parameters that were set in the parameter are updated to the classes dictionary and can later be referenced to as self.key
:return:
"""
for key in kwargs:
self.__dict__[key] = kwargs[key]
def convert2Gray(self, img):
gray = cv2.cvtColor(img,cv2.COLOR_RGB2GRAY)
return gray
def calculateHist(self, gray):
hist = cv2.calcHist([gray],[0],None,[256],[0,256])
return hist
def calculateHistFunction(self, points):
"""
Calculates the curve to plot in the histogram widget
:return:
"""
t = np.linspace(0,1,800)
x0 = np.concatenate(([-1.],points[:,0],[256.]))
y0 = np.concatenate(([0.],points[:,1],[255.]))
t0 = np.concatenate(([0.],np.cumsum(np.sqrt(np.diff(x0)**2+np.diff(y0)**2))))
t0 /= t0[-1]
fx = InterpolatedUnivariateSpline(t0, x0, k=3)
fy = InterpolatedUnivariateSpline(t0, y0, k=3)
x = fx(t)
y = fy(t)
arr = np.zeros(256, dtype=np.uint8)
xi = np.arange(256)
ind = np.searchsorted(xi, x)
arr[ind[ind<256]] = y[ind<256]
arr[xi>points[:,0].max()] = 255
arr[xi<points[:,0].min()] = 0.
arr[arr>255] = 255.
arr[arr<0] = 0.
return measurementPoints, contours
return xi, arr
def closeHoles(self, thresh):
"""
Closes holes in a binary image
:return:
"""
n, labels, stats, centroids = cv2.connectedComponentsWithStats(thresh, 8, cv2.CV_32S)
newthresh = np.zeros_like(thresh)
for label in range(1, n):
up = stats[label, cv2.CC_STAT_TOP]
left = stats[label, cv2.CC_STAT_LEFT]
width = stats[label, cv2.CC_STAT_WIDTH]
height = stats[label, cv2.CC_STAT_HEIGHT]
subimg = np.uint8(255 * (labels[up:(up+height), left:(left+width)] == label))
newthresh[up:(up+height), left:(left+width)] += closeHolesOfSubImage(subimg)
return newthresh
def closeBrightHoles(self, thresh, grayimage, minBrightness):
"""
Only closes holes that are brighter than a given minimal Brightness
:return:
"""
n, labels, stats, centroids = cv2.connectedComponentsWithStats(thresh, 8, cv2.CV_32S)
minBrightness = np.uint8(minBrightness * 255)
print('num comps in brightHoles:', n)
for label in range(1, n):
up = stats[label, cv2.CC_STAT_TOP]
left = stats[label, cv2.CC_STAT_LEFT]
width = stats[label, cv2.CC_STAT_WIDTH]
height = stats[label, cv2.CC_STAT_HEIGHT]
subimg = np.uint8(255 * (labels[up:(up+height), left:(left+width)] == label))
subimg = cv2.copyMakeBorder(subimg, 1, 1, 1, 1, 0)
im_floodfill = subimg.copy()
h, w = subimg.shape[:2]
mask = np.zeros((h+2, w+2), np.uint8)
cv2.floodFill(im_floodfill, mask, (0,0), 255);