def get_edges(self):
# get settings of combobox and fields
param = self._csbox_edges.get_dict()
# get the currently displayed image
img = imgtools.project_data_to_img(imgtools.gray_image(
self.get_obj().get_img(show=True)),
dtype=np.uint8,
factor=255)
aperture_size = param["Aperture Size"]
if (aperture_size % 2) == 0 or aperture_size < 3 or aperture_size > 7:
raise ValueError("Aperture size should be odd between 3 and 7.")
edges = cv2.Canny(img,
param["Threshold I"],
param["Threshold II"],
apertureSize=param["Aperture Size"])
# set image in canvas and update histogram
# self.get_obj().set_img(edges, clear_mask=False)
# self.set_img()
# open a topwindow with the edges of the currently displayed image computed via canny
tw.TopWindow(self, title="Edges", dtype="img", value=[img, edges])
def compute_dimage(self, event=None):
"""Compute the difference image of the currently images in 'd_image'
"""
# continue if two images are provided
if len(self._dimage)<2:
raise IndexError("There are not enough images available to compute the difference.")
# compute the difference image of the currently images in 'd_image'
img_a = self._dimage[-1]
img_b = self._dimage[-2]
# compute the difference image of the currently images in 'd_image'
img = np.absolute(imgtools.gray_image(img_a.astype(np.float32))-imgtools.gray_image(img_b.astype(np.float32)))
#check wheter the image is not empty
if np.sum(img) == 0:
raise ValueError("Sum of differences is zero.")
img = imgtools.project_data_to_img(img)
# set image in canvas and update histogram
self.get_obj().set_img(img, clear_mask=False)
self.set_img()
# open a topwindow with images used for building the difference
tw.TopWindow(self, title="Difference of images", dtype="img", value=[img, img_a, img_b])
def set_popup(self, **kwargs):
t = tw.TopWindow(self._parent,
title="Image Canvas",
dtype="img",
value=self.get_img(show=True),
logger=self._logger)
t.mainloop()
def gradient_image(self):
"""Calculate the horizontal and vertical gradients of the currently displayed image
"""
# https://www.learnopencv.com/histogram-of-oriented-gradients/
# get settings of combobox and fields
param = self._csbox_blur.get_dict()
kernel_size = param["Kernel Size"]
if (kernel_size%2)==0 or kernel_size>32:
raise ValueError("Kernel size must be odd and not larger than 31.")
# get the currently displayed image
img = imgtools.project_data_to_img(imgtools.gray_image(self.get_obj().get_img(show=True)))
# calculate gradient
gradient_x = cv2.Sobel(img, cv2.CV_32F, 1, 0, ksize=kernel_size)
gradient_y = cv2.Sobel(img, cv2.CV_32F, 0, 1, ksize=kernel_size)
# calculate gradient magnitude and direction (in degrees)
magnitude, angle = cv2.cartToPolar(gradient_x, gradient_y, angleInDegrees=True)
# set image in canvas and update histogram
# self.get_obj().set_img(magnitude, clear_mask=False)
# self.set_img()
# open a topwindow with gradient images
tw.TopWindow(self, title="Gradient Image", dtype="img", value=[img, magnitude, gradient_x, gradient_y])
def distance_transform(self, **kwargs):
img_list, _ = self.image_segmentation(show=False, boundaries="find")
img_list[2] = imgtools.get_distance_transform(img_list[1], label=1)
self._img_tw = tw.TopWindow(self,
title="Segmentation",
dtype="img",
value=img_list)
def image_segmentation(self, **kwargs):
"""Compute low-level segmentation methods like felzenswalb'efficient graph based segmentation or k-means based image segementation
https://scikit-image.org/docs/dev/auto_examples/segmentation/plot_segmentations.html#sphx-glr-auto-examples-segmentation-plot-segmentations-py
"""
# get settings of combobox and fields
param = self._csbox_seg.get_dict()
# get the currently displayed image
img = self.get_obj().get_img(show=True)
if param["Model"]=="SLIC" or param["Model"]=="Normalized Cuts":
# https://scikit-image.org/docs/dev/api/skimage.segmentation.html#skimage.segmentation.slic
# n_segments = the (approximate) number of labels in the segmented output image.
# compactness: balances color proximity and space proximity.
# max_iter: maximum number of iterations of k-means.
seg_map = segmentation.slic(img, **self._csbox_slic.get_dict(), start_label=1, convert2lab=1)
seg_map_bound = segmentation.mark_boundaries(img, seg_map)
seg_map_color = color.label2rgb(seg_map, img, kind='avg', bg_label=0)
img_list = [seg_map_bound, seg_map_color]
if param["Model"]=="Normalized Cuts":
# https://scikit-image.org/docs/stable/api/skimage.future.graph.html#skimage.future.graph.cut_normalized
# https://scikit-image.org/docs/dev/auto_examples/segmentation/plot_ncut.html
g = graph.rag_mean_color(img, seg_map, mode='similarity')
seg_map = graph.cut_normalized(seg_map, g)
seg_map_bound = segmentation.mark_boundaries(img, seg_map)
seg_map_color = color.label2rgb(seg_map, img, kind='avg', bg_label=0)
img_list.extend([seg_map_bound, seg_map_color])
elif param["Model"]=="GrabCut":
# https://docs.opencv.org/master/dd/dfc/tutorial_js_grabcut.html
# get settings of combobox and fields
iterCount = self._csbox_grab.get_dict()["iterCount"]
# get the region of interest
roi = self.get_obj().get_roi()
# raise error if the width and height of the roi is not defined
if not sum(roi[2:4]):
raise IndexError("There are no images available.")
# allocate mask, background and foreground model
mask = np.zeros(img.shape[:2],np.uint8)
bgdModel = np.zeros((1,65),np.float64)
fgdModel = np.zeros((1,65),np.float64)
# implement the grabcut algorithm and assign the result of the algorithm to variable img_cut
# define image list for visualization
img_list = [img, img_cut, img[roi[1]:roi[1]+roi[3], roi[0]:roi[0]+roi[2], :]]
# open a topwindow with the segmentation results of the currently displayed image
tw.TopWindow(self, title="Segmentation", dtype="img", value=img_list)
def show_dimage(self, event=None):
"""Show list of difference images in a own topwindow
"""
if not len(self._dimage):
raise IndexError("There are no images available.")
# open a topwindow with images used for building the difference
tw.TopWindow(self, title="Difference of images", dtype="img", value=self._dimage)
def image_segmentation(self, **kwargs):
"""Compute low-level segmentation methods like felzenswalb' efficient graph based segmentation or k-means based image segementation
https://scikit-image.org/docs/dev/auto_examples/segmentation/plot_segmentations.html#sphx-glr-auto-examples-segmentation-plot-segmentations-py
"""
# get settings of combobox and fields
param = self._csbox_seg.get_dict()
# get the currently displayed image
img = self.get_obj().get_img()
# define image list for visualization
img_list = [img]
if param["Model"]=="SLIC":
# https://scikit-image.org/docs/dev/api/skimage.segmentation.html#skimage.segmentation.slic
# n_segments = the (approximate) number of labels in the segmented output image.
# compactness: balances color proximity and space proximity.
# max_iter: maximum number of iterations of k-means.
seg_map = segmentation.slic(img, **self._csbox_slic.get_dict(), start_label=1)
seg_map_bound = segmentation.mark_boundaries(img, seg_map)
seg_map_color = color.label2rgb(seg_map, img, kind='avg', bg_label=0)
# define image list for visualization
img_list.extend([seg_map_bound, seg_map_color])
elif param["Model"]=="Felzenswalb":
# https://scikit-image.org/docs/dev/api/skimage.segmentation.html#skimage.segmentation.felzenszwalb.
seg_map = segmentation.felzenszwalb(img, **self._csbox_felz.get_dict())
seg_map_bound = segmentation.mark_boundaries(img, seg_map)
seg_map_color = color.label2rgb(seg_map, img, kind='avg', bg_label=0)
# define image list for visualization
img_list.extend([seg_map_bound, seg_map_color])
elif param["Model"]=="Normalized Cuts":
# https://scikit-image.org/docs/stable/api/skimage.future.graph.html#skimage.future.graph.cut_normalized
# https://scikit-image.org/docs/dev/auto_examples/segmentation/plot_ncut.html
seg_map = segmentation.slic(img, **self._csbox_slic.get_dict(), start_label=1)
seg_map_bound = segmentation.mark_boundaries(img, seg_map)
seg_map_color = color.label2rgb(seg_map, img, kind='avg', bg_label=0)
g = graph.rag_mean_color(img, seg_map, mode='similarity')
seg_map = graph.cut_normalized(seg_map, g)
seg_map_bound = segmentation.mark_boundaries(img, seg_map)
seg_map_color = color.label2rgb(seg_map, img, kind='avg', bg_label=0)
# define image list for visualization
img_list.extend([seg_map_bound, seg_map_color])
# open a topwindow with the segmentation results of the currently displayed image
self._img_tw = tw.TopWindow(self, title="Segmentation", dtype="img", value=img_list)
self._img_seg = img
self._seg_map = seg_map
def shadow_orientation(self, event=None):
labelimg = imgtools.get_mask_image(
self.get_obj().get_img_from_label("{label}"),
index=self.get_obj().get_class(value=False))
# define the structuring element and apply the opening operation
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (75, 75))
labelimg = cv2.morphologyEx(labelimg, cv2.MORPH_ELLIPSE, kernel)
# get the currently displayed image
grayimg = imgtools.gray_image(self.get_obj().get_img(show=True))
grayimg = cv2.medianBlur(grayimg, 7)
grayimg_label = grayimg * labelimg
# get settings of combobox and fields
param = self._csbox_threshold.get_dict()
thresh = param["Thresh"]
method = cv2.THRESH_BINARY if param[
"Thresh"] else cv2.THRESH_BINARY + cv2.THRESH_OTSU
# implement thresholding and assign the result to the variable dst
ret, dst = cv2.threshold(grayimg_label[grayimg_label != 0], thresh,
255, method)
dst = np.where(grayimg_label < ret, 0, 1)
labelimg_skel = skeletonize(labelimg.astype(np.uint8))
shdwimg = imgtools.gray_image(
np.stack([
imgtools.project_data_to_img(
labelimg, dtype=np.uint8, factor=255),
np.zeros(dst.shape, dtype=np.uint8),
imgtools.project_data_to_img(dst, dtype=np.uint8, factor=255)
],
axis=2))
shdwimg = np.where(labelimg_skel > 0, 255, shdwimg)
shdwimg = np.where(shdwimg == 0, 105, shdwimg)
shdwimg = np.where(shdwimg == 29, 0, shdwimg)
dispimg = self.get_obj().get_img(show=True)
dispimg[:, :, 0] = np.where(labelimg_skel > 0, 0, dispimg[:, :, 0])
dispimg[:, :, 1] = np.where(labelimg_skel > 0, 255, dispimg[:, :, 1])
dispimg[:, :, 2] = np.where(labelimg_skel > 0, 0, dispimg[:, :, 2])
for r in range(1, shdwimg.shape[0] - 1):
for c in range(1, shdwimg.shape[1] - 1):
if len(np.unique(shdwimg[r - 1:r + 2, c - 1:c + 2])) == 3:
cv2.circle(dispimg, (c, r), 3, 255, 2)
tw.TopWindow(self,
title="Segmentation",
dtype="img",
value=[grayimg, shdwimg, grayimg_label, dispimg])
def set_popup(self, dtype="msg", histogram=False, **kwargs):
kwargs.update({
"dtype": dtype,
"q_cmd": self.quit,
"logger": self._logger
})
if dtype == "img":
kwargs.update({
"options": [
o for o in self._options
], # if o["require"] in ["image", "basic", "label", "height"]],
"canvas": {
"variables": self._variables
}
})
if histogram:
if self._cbox_test.get() == "Histogram":
t = twhist.TWHist(self._root, **kwargs)
elif self._cbox_test.get() == "Normal":
t = twhnormal.TWHNormal(self._root, self._param["cloud"],
**kwargs)
elif self._cbox_test.get() == "Filter":
t = twhfilter.TWHFilter(self._root, **kwargs)
elif self._cbox_test.get() == "Features":
t = twhfeatures.TWHFeatures(self._root, **kwargs)
elif self._cbox_test.get() == "Lecture":
t = twhlecture.TWHLecture(self._root, **kwargs)
elif self._cbox_test.get() == "Segmentation":
t = twhseg.TWHSeg(self._root, **kwargs)
elif self._cbox_test.get() == "Segmentation (All)":
t = twseg.TWSeg(self._root, **kwargs)
else:
t = tw.TopWindow(self._root, **kwargs)
else:
t = tw.TopWindow(self._root, **kwargs)
t.mainloop()
def image_segmentation_grabcut(self, **kwargs):
"""Compute low-level segmentation methods like felzenswalb' efficient graph based segmentation or k-means based image segementation
https://scikit-image.org/docs/dev/auto_examples/segmentation/plot_segmentations.html#sphx-glr-auto-examples-segmentation-plot-segmentations-py
"""
# get settings of combobox and fields
param = self._csbox_seg.get_dict()
# get the currently displayed image
img = self.get_obj().get_img()
# define image list for visualization
img_list = [img]
# https://docs.opencv.org/master/dd/dfc/tutorial_js_grabcut.html
# get the region of interest
roi = self.get_obj().get_roi()
# raise error if the width and height of the roi is not defined
if not sum(roi[2:4]):
raise IndexError("There are no images available.")
# allocate mask, background and foreground model
mask = np.zeros(img.shape[:2], np.uint8)
bgdModel = np.zeros((1, 65), np.float64)
fgdModel = np.zeros((1, 65), np.float64)
# this modifies mask
cv2.grabCut(img,
mask,
roi,
bgdModel,
fgdModel,
**self._csbox_grab.get_dict(),
mode=cv2.GC_INIT_WITH_RECT)
# If mask==2 or mask== 1, mask2 get 0, other wise it gets 1 as 'uint8' type.
seg_map = np.where((mask == 2) | (mask == 0), 0, 1).astype('bool')
img_cut = img * seg_map[:, :, np.newaxis]
# define image list for visualization
img_list = [
img, img_cut, img[roi[1]:roi[1] + roi[3],
roi[0]:roi[0] + roi[2], :]
]
# open a topwindow with the segmentation results of the currently displayed image
tw.TopWindow(self, title="Segmentation", dtype="img", value=img_list)
def image_segmentation(self, show=True, **kwargs):
"""Compute low-level segmentation methods like felzenswalb' efficient graph based segmentation or k-means based image segementation
https://scikit-image.org/docs/dev/auto_examples/segmentation/plot_segmentations.html#sphx-glr-auto-examples-segmentation-plot-segmentations-py
"""
# get settings of combobox and fields
param_seg = self._csbox_seg.get_dict()
# get the currently displayed image
img = imgtools.project_and_stack(self.get_obj().get_img_from_label(
param_seg["domain"], dtype=np.uint8, factor=255))
# img = self.get_obj().get_img_from_label("height")
# param_seg["reference"] = self.get_obj().get_img_from_label("height")
param_seg["boundaries"] = "find"
# define image list for visualization
img_list = [img]
mode = param_seg["mode"]
if mode == "SLIC" or mode == "SLIC-0" or mode == "Normalized Cuts":
param_model = self._csbox_slic.get_dict()
elif mode == "Felzenswalb":
param_model = self._csbox_felz.get_dict()
elif mode == "KMeans":
param_model = self._csbox_kmeans.get_dict()
seg = rsvis.utils.imgseg.ImgSeg(**param_seg)
seg.predict(img, **param_model)
img_list.extend([
seg.get_seg_map_color(),
seg.get_seg_map_boundaries(img=imgtools.project_and_stack(
self.get_obj().get_img_from_label(param_seg["reference"]),
dtype=np.uint8,
factor=255))
])
print("Number of segments: {}".format(seg.get_num_label()))
# open a topwindow with the segmentation results of the currently displayed image
if show:
self.get_obj().set_img(img_list[2], clear_mask=False)
self.set_img()
self._img_tw = tw.TopWindow(self,
title="Segmentation",
dtype="img",
value=img_list)
return img_list
def show_box(self, event=None):
"""Show list of boxes
"""
# get the region of interest
roi = self.get_obj().get_roi()
# raise error if the width and height of the roi is not defined
if not sum(roi[2:4]):
raise IndexError("There are no images available.")
# get the currently displayed image
img = self.get_obj().get_img(show=True)
# open a topwindow with images used for building the difference
tw.TopWindow(self, title="Boxes", dtype="img", value=[img[roi[1]:roi[1]+roi[3], roi[0]:roi[0]+roi[2], :]])
def get_hough_transform(self, event=None):
# get settings of combobox and fields
param_edges = self._csbox_edges.get_dict()
param_hough = self._csbox_hough.get_dict()
# get the currently displayed image
img = self.get_obj().get_img(show=True)
grayimg = imgtools.gray_image(img)
aperture_size = param_edges["Aperture Size"]
if (aperture_size % 2) == 0 or aperture_size < 3 or aperture_size > 7:
raise ValueError("Aperture size should be odd between 3 and 7.")
edgeimg = cv2.Canny(grayimg,
param_edges["Threshold I"],
param_edges["Threshold II"],
apertureSize=param_edges["Aperture Size"])
img_list = [img, edgeimg]
lines = cv2.HoughLinesP(
edgeimg,
1,
np.pi / 180,
param_hough["Threshold"],
minLineLength=param_hough["Minimum Line Length"],
maxLineGap=param_hough["Maximum Line Gap"])
if lines is not None:
houghimg = img.copy()
for line in lines:
x1, y1, x2, y2 = line[0]
cv2.line(houghimg, (x1, y1), (x2, y2), (0, 0, 128), 1)
img_list.append(houghimg)
# open a topwindow with the edges of the currently displayed image computed via hough transform
tw.TopWindow(self,
title="Hough Transform",
dtype="img",
value=img_list)
def mtarsi_shadow(self, show=True, **kwargs):
# get the currently displayed image
img = self.get_obj().get_img()
# param_resize = self._csbox_resize.get_dict()
# img = imgtools.resize_image(img, param_resize["factor"])
param_blur = self._csbox_blur.get_dict()
img_filtered = cv2.bilateralFilter(img, param_blur["d"],
param_blur["sigmaColor"],
param_blur["sigmaSpace"])
param_seg = self._csbox_seg.get_dict()
param_seg["mode"] = "SLIC-0"
param_model = self._csbox_slic.get_dict()
seg = rsvis.utils.imgseg.ImgSeg(**param_seg)
seg.predict(img_filtered, **param_model)
seg_map_color = seg.get_seg_map_color()
placeh, placei, placej, placex, grayimg = imgtools.get_placeholder(
img,
seg_map_color,
min_size=self._csbox_shdw_mt.get_dict()["min_size"])
img_list = [img, seg_map_color, grayimg]
self._img_tw = tw.TopWindow(self,
title="Segmentation",
dtype="img",
value=img_list)
plt.plot(placex, placeh)
plt.plot(placex, placei)
plt.plot(placex, placej)
# plt.plot(placex, placej)
plt.ylabel('some numbers')
plt.show()
def show_box(self, event=None):
"""Show list of boxes
"""
# get the region of interest
roi = self.get_obj().get_roi()
# raise error if the width and height of the roi is not defined
if not sum(roi[2:4]):
raise IndexError("There are no images available.")
# get the currently displayed image
img = self.get_obj().get_img(show=True)
# open a topwindow with images used for building the difference
tw.TopWindow(self, title="Boxes", dtype="img", value=[img[roi[1]:roi[1]+roi[3], roi[0]:roi[0]+roi[2], :]])
# # CENTROIDS -----------------------------------------------------------
# # -----------------------------------------------------------------------
# # set combobox and settingsbox for kmeans
# self._csbox_centroids = csbox.CSBox(self, bbox=[["Reset Centroids", "Set Centroids", "Compute Centroids (Color)", "Compute Centroids (Color+Space)"], [self.reset_centroids, self.set_centroids, self.get_centroids_color, self.get_centroids_color_space]], sbox=[["Centroids"], [3], ["int"]])
# self._csbox_centroids.grid(row=4, column=1, rowspan=5, sticky=W+E)
# # method --------------------------------------------------------------
# # -----------------------------------------------------------------------
# def get_cmap(self, n, name='hsv'):
# '''Returns a function that maps each index in 0, 1, ..., n-1 to a distinct
# RGB color; the keyword argument name must be a standard mpl colormap name.'''
# cmap = plt.cm.get_cmap(name, n)
# cmap = [list(cmap(c)[0:3]) for c in range(0, n)]
# return cmap
# # method --------------------------------------------------------------
# # -----------------------------------------------------------------------
# def get_centroids_color(self, event=None):
# img = self.get_obj().get_img(show=True).astype(np.float)
# self._centroids_img_shape = (img.shape[0], img.shape[1])
# data = whiten(img.reshape((-1,3)))
# self.get_centroids(data)
# # method --------------------------------------------------------------
# # -----------------------------------------------------------------------
# def get_centroids_color_space(self, event=None):
# img = self.get_obj().get_img(show=True).astype(np.float)
# self._centroids_img_shape = (img.shape[0], img.shape[1])
# grid = np.indices((self._centroids_img_shape), dtype=np.float)
# data = whiten(np.stack([img[...,0], img[...,1], img[...,2], grid[0], grid[1]], axis=2).reshape((-1,5)))
# self.get_centroids(data)
# # method --------------------------------------------------------------
# # -----------------------------------------------------------------------
# def get_centroids(self, data, event=None):
# if not self._centroids:
# number = self._csbox_centroids.get_dict()["Centroids"]
# codes = number
# minit = "++"
# else:
# number = len(self._centroids)
# codes = np.stack(self._centroids, axis=0).astype(np.float)
# minit = "matrix"
# centroids, label = kmeans2(data, codes, minit=minit)
# label = label.reshape(self._centroids_img_shape)
# mask_list = [np.where(label==idx, 1, 0).astype(np.uint8) for idx in range(len(centroids))]
# mask_color = np.random.randint(0, 255, number*3, dtype=np.uint8).reshape((number,3)).tolist()
# mask_alpha = [150]*number
# mask_invert = [False]*number
# self.get_obj().set_mask(mask=mask_list, color=mask_color
# , invert=mask_invert, alpha=mask_alpha, show=True)
# # method --------------------------------------------------------------
# # -----------------------------------------------------------------------
# def reset_centroids(self, event=None):
# self._centroids = list()
# # method --------------------------------------------------------------
# # -----------------------------------------------------------------------
# def set_centroids(self, event=None):
# self._centroids.append(self.get_obj()._data_img[self.get_obj()._mouse_img[0], self.get_obj()._mouse_img[1], :])
def mtarsi_segmentation(self, show=True, **kwargs):
# get the currently displayed image
img = self.get_obj().get_img()
param = gu.update_dict(self._csbox_seg_mt.get_dict(),
self._csbox_blur.get_dict())
# define image list for visualization
img_list = [img]
cluster_list = list()
new_shape = (math.ceil(img.shape[0] * param["factor"]),
math.ceil(img.shape[1] * param["factor"]))
img = cv2.resize(img, (new_shape[1], new_shape[0]),
dst=cv2.CV_8UC3,
interpolation=cv2.INTER_CUBIC)
for i in range(param["n_filters"]):
img = cv2.bilateralFilter(img, param["Diameter"],
param["Sigma Color"],
param["Sigma Space"])
img_list.append(img)
slic = rsvis.utils.imgseg.segmentation_slic(
img,
**gu.update_dict(
self._csbox_slic.get_dict(),
{"n_segments": (int(img.shape[0] + img.shape[1]) * 4)}),
**self._csbox_bound.get_dict(),
slic_zero=True)
img_list.append(slic[1])
cluster = rsvis.utils.imgseg.segmentation_kmeans_color(
img, **self._csbox_kmeans.get_dict(),
**self._csbox_bound.get_dict())
print(np.unique(cluster[0]))
cluster_list.append(cluster[0])
img_list.append(
imgtools.project_data_to_img(cluster[0],
dtype=np.uint8,
factor=255))
param_cluster = self._csbox_kmeans.get_dict()
param_cluster["non_pos"] = 1
cluster = rsvis.utils.imgseg.segmentation_kmeans_color_pos(
img, **param_cluster, **self._csbox_bound.get_dict())
print(np.unique(cluster[0]))
cluster_list.append(cluster[0])
img_list.append(
imgtools.project_data_to_img(cluster[0],
dtype=np.uint8,
factor=255))
param_cluster["non_pos"] = 0
cluster = rsvis.utils.imgseg.segmentation_kmeans_color_pos(
img, **param_cluster, **self._csbox_bound.get_dict())
print(np.unique(cluster[0]))
cluster_list.append(cluster[0])
img_list.append(
imgtools.project_data_to_img(cluster[0],
dtype=np.uint8,
factor=255))
n_clusters = param_cluster["n_clusters"]
img_new = np.zeros(img.shape[:2], dtype=np.uint8)
clstr_img_src = cluster_list[0]
clstr_img_dst = cluster_list[1]
clstr_img_est = cluster_list[2]
clstr_cmp_src_dst = np.zeros((n_clusters, 2))
for clstr in range(n_clusters):
# clstr_cmp = clstr_img_dst[clstr_img_src==clstr]
# print(clstr_cmp.shape, np.unique(clstr_cmp))
# print(clstr_img_src.shape,np.unique(clstr_img_src))
# print(clstr_img_dst.shape,np.unique(clstr_img_dst))
# print(clstr)
clstr_src_dst = clstr_img_dst[(clstr_img_src == clstr).astype(
np.bool)]
# bbbb = np.where(clstr_img_src==clstr, clstr_img_dst, -1).astype(np.int8)
# clstr_hist = np.histogram(bbbb, bins=range(0,n_clusters+1))
# clstr_hist_norm = clstr_hist[0]/np.sum(clstr_hist[0])
# print(clstr_hist_norm)
clstr_hist = np.histogram(clstr_src_dst,
bins=range(0, n_clusters + 1))
clstr_hist_norm = clstr_hist[0] / np.sum(clstr_hist[0])
print(clstr_hist_norm)
hist_max = np.amax(clstr_hist_norm)
print(hist_max)
hist_max_idx = int(np.where(clstr_hist_norm == hist_max)[0])
print("Max: {}, Idx-Max: {}, Stats: {}".format(
hist_max, hist_max_idx, np.std(clstr_hist_norm)))
clstr_cmp_src_dst = hist_max_idx
cc = False
if np.std(clstr_hist_norm) > 0.3:
cc = True
clstr_dst_src = clstr_img_src[clstr_img_dst == hist_max_idx]
# bbbb = np.where(clstr_img_dst==hist_max_idx, clstr_img_src, -1).astype(np.int8)
# clstr_hist = np.histogram(bbbb, bins=range(0,n_clusters+1))
# clstr_hist_norm = clstr_hist[0]/np.sum(clstr_hist[0])
# print(clstr_hist_norm)
clstr_hist = np.histogram(clstr_dst_src,
bins=range(0, n_clusters + 1))
clstr_hist_norm = clstr_hist[0] / np.sum(clstr_hist[0])
print(clstr_hist_norm)
hist_max = np.amax(clstr_hist_norm)
print(hist_max)
hist_max_idx = int(np.where(clstr_hist_norm == hist_max)[0])
print("Max: {}, Idx-Max: {}, Stats: {}".format(
hist_max, hist_max_idx, np.std(clstr_hist_norm)))
if clstr == hist_max_idx and cc:
print("oberblubber")
clstr_src_dst = clstr_img_est[(clstr_img_src == clstr).astype(
np.bool)]
clstr_hist = np.histogram(clstr_src_dst,
bins=range(0, n_clusters + 1))
clstr_hist_norm = clstr_hist[0] / np.sum(clstr_hist[0])
# print(clstr_hist_norm)
hist_max = np.amax(clstr_hist_norm)
# print(hist_max)
hist_max_idx = int(np.where(clstr_hist_norm == hist_max)[0])
# print("Max: {}, Idx-Max: {}, Stats: {}".format(hist_max, hist_max_idx, np.std(clstr_hist_norm)))
clstr_cmp_src_est = hist_max_idx
cc = False
if np.std(clstr_hist_norm) > 0.3:
cc = True
clstr_dst_src = clstr_img_src[clstr_img_est == hist_max_idx]
clstr_hist = np.histogram(clstr_dst_src,
bins=range(0, n_clusters + 1))
clstr_hist_norm = clstr_hist[0] / np.sum(clstr_hist[0])
# print(clstr_hist_norm)
hist_max = np.amax(clstr_hist_norm)
# print(hist_max)
hist_max_idx = int(np.where(clstr_hist_norm == hist_max)[0])
if clstr == hist_max_idx and cc:
print("blubber")
img_new += np.where(clstr_img_src == clstr, 1,
0).astype(np.uint8)
print(clstr_cmp_src_dst)
img_list.append(img_new)
# # # # seg_map_slic, seg_map_color_slic, seg_map_bound_slic = rsvis.utils.imgseg.segmentation_slic(img, **gu.update_dict(self._csbox_slic.get_dict(), {"n_segments":(int(img.shape[0]+img.shape[1])/2)}), **self._csbox_bound.get_dict(), slic_zero=True)
# # # # seg_map_kmeans, seg_map_bound_kmeans = rsvis.utils.imgseg.segmentation_kmeans_color(img, **self._csbox_kmeans.get_dict(), **self._csbox_bound.get_dict())
# # # # # define image list for visualization
# # # # img_list.extend([seg_map_bound_kmeans, seg_map_bound_slic])
# # # # seg_map_bound_kmeans = imgtools.project_data_to_img(seg_map_bound_kmeans,dtype=np.uint8, factor=255)
# # # # seg_map_kmeans = seg_map_kmeans.astype(np.uint8)
# # # # num = np.unique(seg_map_kmeans)
# # # # seg_map_kmeans_new= np.zeros(seg_map_kmeans.shape, dtype=np.uint8)
# # # # for i in np.unique(seg_map_slic):
# # # # mask = np.where(seg_map_slic==i, 1, 0).astype(np.ubyte)
# # # # hist = cv2.calcHist([seg_map_kmeans], [0], mask, [len(num)], [0,len(num)])
# # # # hist_max_index = np.where(hist == np.amax(hist))
# # # # if len(hist_max_index[0]) > 1:
# # # # hist_max_index = hist_max_index[0]
# # # # seg_map_kmeans_new += mask.astype(np.uint8)[:,:,np.newaxis]*np.uint8(hist_max_index[0])
# # # # seg_map_kmeans_new_map = imgtools.project_data_to_img(seg_map_kmeans_new, factor=255, dtype=np.uint8)
# # # # img_list.extend([seg_map_kmeans_new_map])
# # # # hist = cv2.calcHist([seg_map_kmeans_new], [0], None, [len(num)], [0,len(num)])
# # # # hist_max_count = np.where(hist == np.amax(hist))
# # # # hist_list=[hist_max_count[0]]
# # # # for i in num:
# # # # hist[i] = np.mean(img[np.concatenate([seg_map_kmeans_new]*3, axis=2)==i])
# # # # hist_min_bright = np.where(hist == np.amin(hist))
# # # # hist_list.append(hist_min_bright[0])
# # # # print(hist_list)
# # # # aba = [i for i in num if i not in hist_list]
# # # # # allocate mask, background and foreground model
# # # # seg_map_kmeans_new = seg_map_kmeans_new.astype(np.uint8)
# # # # mask = np.zeros(img.shape[:2],dtype=np.uint8)
# # # # mask += np.uint8(2)*np.where(np.squeeze(seg_map_kmeans_new, axis=2)==np.uint8(hist_max_count),1,0).astype(np.uint8)
# # # # mask += np.uint8(3)*np.where(np.squeeze(seg_map_kmeans_new, axis=2)==np.uint8(hist_min_bright[0]),1,0).astype(np.uint8)
# # # # mask += np.uint8(3)*np.where(np.squeeze(seg_map_kmeans_new, axis=2)==np.uint8(aba[0]),1,0).astype(np.uint8)
# # # # bgdModel = np.zeros((1,65),np.float64)
# # # # fgdModel = np.zeros((1,65),np.float64)
# # # # w,h,d = img.shape
# # # # roi = (0,0,w,h)
# # # # # this modifies mask
# # # # seg_map_slic, seg_map_color_slic, seg_map_bound_slic = rsvis.utils.imgseg.segmentation_slic(img, **gu.update_dict(self._csbox_slic.get_dict(), {"n_segments":(int(img.shape[0]+img.shape[1])*4)}), **self._csbox_bound.get_dict(), slic_zero=True)
# # # # img_list.extend([imgtools.project_data_to_img(mask,factor=255, dtype=np.uint8)])
# # # # # cv2.grabCut(cv2.bilateralFilter(img, d=5, sigmaColor=100, sigmaSpace=500), mask, roi, bgdModel, fgdModel, 10, mode=cv2.GC_INIT_WITH_MASK)
# # # # cv2.grabCut(img, mask, roi, bgdModel, fgdModel, 40, mode=cv2.GC_INIT_WITH_MASK)
# # # # # If mask==2 or mask== 1, mask2 get 0, other wise it gets 1 as 'uint8' type.
# # # # seg_map = np.where((mask==2)|(mask==0), 0, 1).astype('bool')
# # # # seg_map = img*seg_map[:,:,np.newaxis]
# # # # img_list.extend([seg_map])
# # # # seg_map = np.where((mask==2)|(mask==0), 1, 0).astype('bool')
# # # # seg_map = img*seg_map[:,:,np.newaxis]
# # # # img_list.extend([seg_map])
# open a topwindow with the segmentation results of the currently displayed image
if show:
self._img_tw = tw.TopWindow(self,
title="Segmentation",
dtype="img",
value=img_list)
def blubb(self, **kwargs):
img = self.get_obj().get_img()
param_blur = self._csbox_blur.get_dict()
img_filtered = cv2.bilateralFilter(img, param_blur["d"],
param_blur["sigmaColor"],
param_blur["sigmaSpace"])
seg_list_a = list()
img_list_a = list()
param_model = self._csbox_kmeans.get_dict()
param_seg = self._csbox_seg.get_dict()
param_seg["kind"] = "overlay"
param_seg["mode"] = "KMeans"
param_seg["color"] = 1
param_seg["position"] = 0
n_clusters = 3
for i in range(3):
param_model["n_clusters"] = n_clusters
seg = rsvis.utils.imgseg.ImgSeg(**param_seg)
seg.predict(img_filtered, **param_model)
seg_list_a.append(seg.get_seg_map())
img_list_a.append(seg.get_seg_map_color())
n_clusters += 1
param_seg["position"] = 1
n_clusters = 3
seg_list_b = list()
img_list_b = list()
n_clusters = 6
for i in range(3):
param_model["n_clusters"] = n_clusters
seg = rsvis.utils.imgseg.ImgSeg(**param_seg)
seg.predict(img_filtered, **param_model)
seg_list_b.append(seg.get_seg_map())
img_list_b.append(seg.get_seg_map_color())
n_clusters += 1
# param_seg["color"] = 0
# param_seg["position"] = 1
# n_clusters = 3
# seg_list_c = list()
# img_list_c = list()
# n_clusters = 4
# for i in range(3):
# param_model["n_clusters"] = n_clusters
# seg = rsvis.utils.imgseg.ImgSeg(**param_seg)
# seg.predict(img_filtered, **param_model)
# seg_list_c.append(seg.get_seg_map())
# img_list_c.append(seg.get_seg_map_color())
# n_clusters += 1
img_list_a.extend(img_list_b)
# img_list_a.extend(img_list_c)
segcmp = rsvis.utils.imgsegcmp.ImgSegCmp()
segcmp.predict(seg_list_a)
segcmp.predict(seg_list_b)
self._img_tw = tw.TopWindow(self,
title="Segmentation",
dtype="img",
value=img_list_a)
