def refineBorder(self, box, blob, img, mask, grow):
try:
from coraline.Coraline import segment
segment(img, mask, 0.0, conservative=0.07, grow=grow, radius=30)
except Exception as e:
msgBox = QMessageBox()
msgBox.setText(str(e))
msgBox.exec()
return
#TODO this should be moved to a function!
area_th = 30
created_blobs = []
first = True
label_image = measure.label(mask, connectivity=1)
for region in measure.regionprops(label_image):
if region.area > area_th:
b = Blob(region, box[1], box[0], self.progressive_id)
self.progressive_id += 1
b.class_color = blob.class_color
b.class_name = blob.class_name
created_blobs.append(b)
return created_blobs
def import_label_map(self,
filename,
labels_info,
w_target,
h_target,
create_holes=False):
"""
It imports a label map and create the corresponding blobs.
The label map is rescaled such that it coincides with the reference map.
"""
qimg_label_map = QImage(filename)
qimg_label_map = qimg_label_map.convertToFormat(QImage.Format_RGB32)
if w_target > 0 and h_target > 0:
qimg_label_map = qimg_label_map.scaled(w_target, h_target,
Qt.IgnoreAspectRatio,
Qt.FastTransformation)
label_map = utils.qimageToNumpyArray(qimg_label_map)
label_map = label_map.astype(np.int32)
# RGB -> label code association (ok, it is a dirty trick but it saves time..)
label_coded = label_map[:, :, 0] + (label_map[:, :, 1] << 8) + (
label_map[:, :, 2] << 16)
labels = measure.label(label_coded, connectivity=1)
too_much_small_area = 50
region_big = None
created_blobs = []
for region in measure.regionprops(labels):
if region.area > too_much_small_area:
id = len(self.seg_blobs)
blob = Blob(region, 0, 0, self.getFreeId())
# assign class
row = region.coords[0, 0]
col = region.coords[0, 1]
color = label_map[row, col]
for label_name in labels_info.keys():
c = labels_info[label_name]
if c[0] == color[0] and c[1] == color[1] and c[2] == color[
2]:
blob.class_name = label_name
blob.class_color = c
break
if create_holes or blob.class_name is not 'Empty':
created_blobs.append(blob)
return created_blobs
def import_label_map(self, filename, reference_map):
"""
It imports a label map and create the corresponding blobs.
The label map is rescaled such that it coincides with the reference map.
"""
qimg_label_map = QImage(filename)
qimg_label_map = qimg_label_map.convertToFormat(QImage.Format_RGB32)
w = reference_map.width()
h = reference_map.height()
qimg_label_map = qimg_label_map.scaled(w, h, Qt.IgnoreAspectRatio,
Qt.SmoothTransformation)
label_map = utils.qimageToNumpyArray(qimg_label_map)
label_map = label_map.astype(np.int32)
# RGB -> label code association (ok, it is a dirty trick but it saves time..)
label_coded = label_map[:, :, 0] + (label_map[:, :, 1] << 8) + (
label_map[:, :, 2] << 16)
labels = measure.label(label_coded, connectivity=1)
label_info = Labels()
too_much_small_area = 10
region_big = None
created_blobs = []
for region in measure.regionprops(labels):
if region.area > too_much_small_area:
id = len(self.seg_blobs)
blob = Blob(region, 0, 0, id + 1)
# assign class
row = region.coords[0, 0]
col = region.coords[0, 1]
color = label_map[row, col]
index = label_info.searchColor(color)
if index >= 0:
blob.class_name = label_info.getClassName(index)
blob.class_color = label_info.getColorByIndex(index)
created_blobs.append(blob)
return created_blobs
def import_label_map(self, filename, reference_map):
"""
It imports a label map and create the corresponding blobs.
The label map is rescaled such that it coincides with the reference map.
"""
qimg_label_map = QImage(filename)
qimg_label_map = qimg_label_map.convertToFormat(QImage.Format_RGB32)
w = reference_map.width()
h = reference_map.height()
qimg_label_map = qimg_label_map.scaled(w, h, Qt.IgnoreAspectRatio,
Qt.SmoothTransformation)
label_map = utils.qimageToNumpyArray(qimg_label_map)
label_map = label_map.astype(np.int32)
# RGB -> label code association (ok, it is a dirty trick but it saves time..)
label_coded = label_map[:, :, 0] + (label_map[:, :, 1] << 8) + (
label_map[:, :, 2] << 16)
labels = measure.label(label_coded, connectivity=1)
too_much_small_area = 1000
region_big = None
created_blobs = []
for region in measure.regionprops(labels):
if region.area > too_much_small_area:
id = len(self.seg_blobs)
blob = Blob(region, 0, 0, self.progressive_id)
self.progressive_id += 1
# assign class
row = region.coords[0, 0]
col = region.coords[0, 1]
color = label_map[row, col]
for label_name in self.labels_info.keys():
c = self.labels_info[label_name]
if c[0] == color[0] and c[1] == color[1] and c[2] == color[
2]:
blob.class_name = label_name
blob.class_color = c
break
created_blobs.append(blob)
return created_blobs
def cut(self, blob, lines):
"""
Given a curve specified as a set of points and a selected blob, the operation cuts it in several separed new blobs
"""
points = blob.lineToPoints(lines, snap=False)
mask = blob.getMask()
original = mask.copy()
box = blob.bbox
#box is y, x, w, h
Mask.paintPoints(mask, box, points, 0)
label_image = measure.label(mask, connectivity=1)
for point in points:
x = point[0] - box[1]
y = point[1] - box[0]
if x <= 0 or y <= 0 or x >= box[2] - 1 or y >= box[3] - 1:
continue
if original[y][x] == 0:
continue
largest = 0
largest = max(label_image[y + 1][x], largest)
largest = max(label_image[y - 1][x], largest)
largest = max(label_image[y][x + 1], largest)
largest = max(label_image[y][x - 1], largest)
label_image[y][x] = largest
area_th = 30
created_blobs = []
first = True
for region in measure.regionprops(label_image):
if region.area > area_th:
b = Blob(region, box[1], box[0], self.progressive_id)
self.progressive_id += 1
b.class_color = blob.class_color
b.class_name = blob.class_name
created_blobs.append(b)
return created_blobs
def refineBorder(self, box, blob, img, depth, mask, grow, lastedit):
clippoints = None
if lastedit is not None:
points = [blob.drawLine(line) for line in lastedit]
if points is not None and len(points) > 0:
clippoints = np.empty(shape=(0, 2), dtype=int)
for arc in points:
clippoints = np.append(clippoints, arc, axis=0)
origin = np.array([box[1], box[0]])
clippoints = clippoints - origin
try:
from coraline.Coraline import segment
segment(img,
depth,
mask,
clippoints,
0.0,
conservative=self.refine_conservative,
grow=grow,
radius=30,
depth_weight=self.refine_depth_weight)
except Exception as e:
print(e, flush=True)
#msgBox = QMessageBox()
#msgBox.setText(str(e))
#msgBox.exec()
# return
#TODO this should be moved to a function!
area_th = 2
created_blobs = []
first = True
label_image = measure.label(mask, connectivity=1)
for region in measure.regionprops(label_image):
if region.area > area_th:
b = Blob(region, box[1], box[0], self.getFreeId())
b.class_color = blob.class_color
b.class_name = blob.class_name
created_blobs.append(b)
return created_blobs
def createCrack(self, blob, input_arr, x, y, tolerance, preview=True):
"""
Given a inner blob point (x,y), the function use it as a seed for a paint butcket tool and create
a correspondent blob hole
"""
box = blob.bbox
x_crop = x - box[1]
y_crop = y - box[0]
input_arr = gaussian(input_arr, 2)
# input_arr = segmentation.inverse_gaussian_gradient(input_arr, alpha=1, sigma=1)
blob_mask = blob.getMask()
crack_mask = flood(input_arr, (int(y_crop), int(x_crop)),
tolerance=tolerance).astype(int)
cracked_blob = np.logical_and((blob_mask > 0), (crack_mask < 1))
cracked_blob = cracked_blob.astype(int)
if preview:
return cracked_blob
regions = measure.regionprops(measure.label(cracked_blob))
area_th = 1000
created_blobs = []
for region in regions:
if region.area > area_th:
id = len(self.seg_blobs)
b = Blob(region, box[1], box[0], self.progressive_id)
self.progressive_id += 1
b.class_color = blob.class_color
b.class_name = blob.class_name
created_blobs.append(b)
return created_blobs
def cut(self, blob, lines):
"""
Given a curve specified as a set of points and a selected blob, the operation cuts it in several separed new blobs
"""
points = blob.lineToPoints(lines)
mask = blob.getMask()
box = blob.bbox
Mask.paintPoints(mask, box, points, 0)
label_image = measure.label(mask)
area_th = 30
created_blobs = []
for region in measure.regionprops(label_image):
if region.area > area_th:
id = len(self.seg_blobs)
b = Blob(region, box[1], box[0], id + 1)
b.class_color = blob.class_color
b.class_name = blob.class_name
created_blobs.append(b)
return created_blobs
def splitBlob(self, map, blob, seeds):
seeds = np.asarray(seeds)
seeds = seeds.astype(int)
mask = blob.getMask()
box = blob.bbox
cropimg = utils.cropQImage(map, box)
cropimgnp = rgb2gray(utils.qimageToNumpyArray(cropimg))
edges = sobel(cropimgnp)
# x,y
seeds_matrix = np.zeros_like(mask)
size = 40
#
for i in range(0, seeds.shape[0]):
#y,x
seeds_matrix[seeds[i, 1] - box[0] - (size - 1):seeds[i, 1] -
box[0] + (size - 1), seeds[i, 0] - box[1] -
(size - 1):seeds[i, 0] - box[1] + (size - 1)] = 1
distance = ndi.distance_transform_edt(mask)
# distance = ndi.distance_transform_edt(cropimg)
seeds_matrix = seeds_matrix > 0.5
markers = ndi.label(seeds_matrix)[0]
# labels = watershed(-distance, markers, mask=mask)
labels = watershed((-distance + 100 * edges) / 2, markers, mask=mask)
created_blobs = []
for region in measure.regionprops(labels):
b = Blob(region, box[1], box[0], self.progressive_id)
self.progressive_id += 1
b.class_color = blob.class_color
b.class_name = blob.class_name
created_blobs.append(b)
return created_blobs
def segmentation(self):
# compute bbox of scribbles (working area)
bboxes = []
for i, curve in enumerate(self.scribbles.points):
bbox = Mask.pointsBox(curve, int(self.scribbles.size[i] / 2))
bboxes.append(bbox)
working_area = Mask.jointBox(bboxes)
if working_area[0] < 0:
working_area[0] = 0
if working_area[1] < 0:
working_area[1] = 0
if working_area[0] + working_area[3] > self.viewerplus.img_map.height(
) - 1:
working_area[3] = self.viewerplus.img_map.height(
) - 1 - working_area[0]
if working_area[1] + working_area[2] > self.viewerplus.img_map.width(
) - 1:
working_area[2] = self.viewerplus.img_map.width(
) - 1 - working_area[1]
crop_img = utils.cropQImage(self.viewerplus.img_map, working_area)
crop_imgnp = utils.qimageToNumpyArray(crop_img)
# create markers
mask = np.zeros((working_area[3], working_area[2], 3), dtype=np.int32)
color_codes = dict()
counter = 1
for i, curve in enumerate(self.scribbles.points):
col = self.scribbles.label[i].fill
b = col[2]
g = col[1]
r = col[0]
color = (b, g, r)
color_code = b + 256 * g + 65536 * r
color_key = str(color_code)
if color_codes.get(color_key) is None:
name = self.scribbles.label[i].name
color_codes[color_key] = (counter, name)
counter = counter + 1
curve = np.int32(curve)
curve[:, 0] = curve[:, 0] - working_area[1]
curve[:, 1] = curve[:, 1] - working_area[0]
curve = curve.reshape((-1, 1, 2))
mask = cv2.polylines(mask,
pts=[curve],
isClosed=False,
color=color,
thickness=self.scribbles.size[i],
lineType=cv2.LINE_8)
mask = np.uint8(mask)
markers = np.zeros((working_area[3], working_area[2]), dtype='int32')
for label in self.scribbles.label:
col = label.fill
b = col[2]
g = col[1]
r = col[0]
color_code = b + 256 * g + 65536 * r
color_key = str(color_code)
idx = np.where((mask[:, :, 0] == b) & (mask[:, :, 1] == g)
& (mask[:, :, 2] == r))
(value, name) = color_codes[color_key]
markers[idx] = value
# markers = np.int32(255*rgb2gray(mask))
# markersprint = 255*rgb2gray(mask)
markersprint = markers
cv2.imwrite('mask.png', markersprint)
# watershed segmentation
segmentation = cv2.watershed(crop_imgnp, markers)
segmentation = filters.median(segmentation, disk(5), mode="mirror")
cv2.imwrite('segmentation.png', segmentation)
# the result of the segmentation must be converted into labels again
lbls = measure.label(segmentation)
blobs = []
for region in measure.regionprops(lbls):
blob = Blob(region, working_area[1], working_area[0],
self.viewerplus.annotations.getFreeId())
color_index = segmentation[region.coords[0][0],
region.coords[0][1]]
data = list(color_codes.items())
index = 0
for i in range(len(data)):
(color_code, t) = data[i]
if t[0] == color_index:
color_code = int(color_code)
r = int(color_code / 65536)
g = int(int(color_code - r * 65536) / 256)
b = int(color_code - r * 65536 - g * 256)
color = [r, g, b]
name = t[1]
break
blob.class_color = color
blob.class_name = name
blobs.append(blob)
return blobs
