def test_h_maxima(self): "h-maxima for various data types" data = np.array([[10, 11, 13, 14, 14, 15, 14, 14, 13, 11], [11, 13, 15, 16, 16, 16, 16, 16, 15, 13], [13, 15, 40, 40, 18, 18, 18, 60, 60, 15], [14, 16, 40, 40, 19, 19, 19, 60, 60, 16], [14, 16, 18, 19, 19, 19, 19, 19, 18, 16], [15, 16, 18, 19, 19, 20, 19, 19, 18, 16], [14, 16, 18, 19, 19, 19, 19, 19, 18, 16], [14, 16, 80, 80, 19, 19, 19, 100, 100, 16], [13, 15, 80, 80, 18, 18, 18, 100, 100, 15], [11, 13, 15, 16, 16, 16, 16, 16, 15, 13]], dtype=np.uint8) expected_result = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=np.uint8) for dtype in [np.uint8, np.uint64, np.int8, np.int64]: data = data.astype(dtype) out = extrema.h_maxima(data, 40) error = diff(expected_result, out) assert error < eps
def predict(model, dataloader=None, image=None): model.eval() device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") if image is not None: image = image[0].to(device=device)[None, :, :, :] start_time = time.time() with torch.no_grad(): outputs = model(image) out = outputs[0, 0, :, :].numpy() h = 0.3 h_maxima = extrema.h_maxima(out, h) coordinates_h = peak_local_max(h_maxima, indices=True) elapsed_time = time.time() - start_time pred_x = coordinates_h[:, 1] pred_y = coordinates_h[:, 0] image = image[0, 0, :, :].detach().cpu().numpy() return image, pred_x, pred_y for i, (inputs, name) in enumerate(dataloader): name = name[0] start_time = time.time() with torch.no_grad(): inputs = inputs[0].to(device=device)[None, :, :, :] outputs = model(inputs) out = outputs[0, 0, :, :].numpy() h = 0.3 h_maxima = extrema.h_maxima(out, h) coordinates_h = peak_local_max(h_maxima, indices=True) elapsed_time = time.time() - start_time fig = plt.figure(dpi=300) ax = fig.add_subplot(1, 1, 1) ax.imshow(inputs[0, 0, :, :].detach().cpu().numpy(), cmap="gray") ax.plot(coordinates_h[:, 1], coordinates_h[:, 0], 'r+', markersize=10) print(f"{name}, time: {elapsed_time}") plt.show() break
def h_max_transform(img, h): # if h <= 0: # h = 1 # else: # h = 1/h print("Foci threshold is " + str(h)) h_maxima = extrema.h_maxima(img, h) label_h_maxima = label(h_maxima) label_h_maxima[label_h_maxima > 0] = 255 return label_h_maxima
def test_extrema_float(self): "specific tests for float type" data = np.array( [[0.10, 0.11, 0.13, 0.14, 0.14, 0.15, 0.14, 0.14, 0.13, 0.11], [0.11, 0.13, 0.15, 0.16, 0.16, 0.16, 0.16, 0.16, 0.15, 0.13], [0.13, 0.15, 0.40, 0.40, 0.18, 0.18, 0.18, 0.60, 0.60, 0.15], [0.14, 0.16, 0.40, 0.40, 0.19, 0.19, 0.19, 0.60, 0.60, 0.16], [0.14, 0.16, 0.18, 0.19, 0.19, 0.19, 0.19, 0.19, 0.18, 0.16], [0.15, 0.182, 0.18, 0.19, 0.204, 0.20, 0.19, 0.19, 0.18, 0.16], [0.14, 0.16, 0.18, 0.19, 0.19, 0.19, 0.19, 0.19, 0.18, 0.16], [0.14, 0.16, 0.80, 0.80, 0.19, 0.19, 0.19, 1.0, 1.0, 0.16], [0.13, 0.15, 0.80, 0.80, 0.18, 0.18, 0.18, 1.0, 1.0, 0.15], [0.11, 0.13, 0.15, 0.16, 0.16, 0.16, 0.16, 0.16, 0.15, 0.13]], dtype=np.float32) inverted_data = 1.0 - data expected_result = np.array( [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=np.uint8) # test for local maxima with automatic step calculation out = extrema.local_maxima(data) error = diff(expected_result, out) assert error < eps # test for local minima with automatic step calculation out = extrema.local_minima(inverted_data) error = diff(expected_result, out) assert error < eps out = extrema.h_maxima(data, 0.003) expected_result = np.array( [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=np.uint8) error = diff(expected_result, out) assert error < eps out = extrema.h_minima(inverted_data, 0.003) error = diff(expected_result, out) assert error < eps
def getExtrema(self): Extrema = np.array([0, 0, 0]) img = self.ch1 image_gray = img image_rgb = img im = self.runHistogramAbs(img) # im = ndimage.gaussian_filter(im, sigma=0.7) # im = exposure.rescale_intensity(im) im = ndimage.gaussian_filter(im, sigma=1) im = exposure.rescale_intensity(im) h = 0.2 h_maxima = extrema.h_maxima(im, h) label_h_maxima = label(h_maxima) Extrema[0] = np.count_nonzero(label_h_maxima) #check if the extrema is right next to the edge if Extrema[0] == 1: indices = np.nonzero(h_maxima) distance = im.shape[1] - indices[1] Extrema[2] = distance[0] img = self.ch6 image_gray = img image_rgb = img im = self.runHistogramAbs(img) # im = ndimage.gaussian_filter(im, sigma=0.7) im = ndimage.gaussian_filter(im, sigma=1) im = exposure.rescale_intensity(im) h = 0.2 h_maxima = extrema.h_maxima(im, h) label_h_maxima = label(h_maxima) Extrema[1] = np.count_nonzero(label_h_maxima) params = self.getParams() Extrema = np.append(Extrema, params) return Extrema
def segment_watershed(pixels: np.array, extreme_val: int, bg_val: int): """ Returns an np.array that is the segmented version of the input Finds local maxima using extreme_val as the minimal height for the maximum, Then uses the local maxima and background pixels (pixels that are smaller than bg_val) to execute a watershed segmentation """ maxima = extrema.h_maxima(pixels, extreme_val) elevation_map = sobel(pixels) markers = np.zeros_like(pixels) markers[pixels < bg_val] = 1 markers[maxima == 1] = 2 return segmentation.watershed(elevation_map, markers)
def h_max_transform(img, h): if h <= 0: h = 1 else: h = 1 / h print("Foci threshold is " + str(h)) h_maxima = extrema.h_maxima(img, h) label_h_maxima = label(h_maxima) overlay_h = color.label2rgb(label_h_maxima, img, alpha=0.7, bg_label=0, bg_color=None, colors=[(1, 0, 0)]) return overlay_h
def ExtractCandidates(im_norm, h, radius, nbit): """extract signal candidates applying h_maxima transform INPUTS: im_norm=normalised image, h=h_maxima threshold, radius=structuring element radius, nbit= encoding""" #top_hat filtering se = ball(radius) im = white_tophat(im_norm, se) connectivity = np.array([[[0, 0, 0], [0, 1, 0], [0, 0, 0]], [[0, 1, 0], [1, 1, 1], [0, 1, 0]], [[0, 0, 0], [0, 1, 0], [0, 0, 0]]]) #3D corss #filtering local maxima h_maxima = extrema.h_maxima(im, h, selem=connectivity) label_h_max = label(h_maxima, neighbors=4) labels = pd.DataFrame( data={'labels': np.sort(label_h_max[np.where(label_h_max != 0)])}) dup = labels.index[labels.duplicated() == True].tolist( ) #find duplicates labels (=connected components) #splitting connected regions to get only one local maxima max_mask = np.zeros(im.shape) max_mask[label_h_max != 0] = np.iinfo(nbit).max for i in range(len(dup)): z, r, c = np.where(label_h_max == labels.loc[ dup[i], 'labels']) #find coord of points having the same label meanpoint_x = np.mean(c) meanpoint_y = np.mean(r) meanpoint_z = np.mean(z) dist = [ distance.euclidean([meanpoint_z, meanpoint_y, meanpoint_x], [z[j], r[j], c[j]]) for j in range(len(r)) ] ind = dist.index(min(dist)) z, r, c = np.delete(z, ind), np.delete(r, ind), np.delete( c, ind) #delete values at ind position. max_mask[z, r, c] = 0 #set to 0 points != medoid coordinates ## overlay_h=color.label2rgb(label_h_max, im, alpha=1, bg_label=0, bg_color=None, colors=[(0,1,0)]) ## plt.figure() ## plt.imshow(overlay_h,interpolation='none') return max_mask
def test_h_maxima_float_image(self): """specific tests for h-maxima float image type""" w = 10 x, y = np.mgrid[0:w, 0:w] data = 20 - 0.2 * ((x - w / 2) ** 2 + (y - w / 2) ** 2) data[2:4, 2:4] = 40 data[2:4, 7:9] = 60 data[7:9, 2:4] = 80 data[7:9, 7:9] = 100 data = data.astype(np.float32) expected_result = np.zeros_like(data) expected_result[(data > 19.9)] = 1.0 for h in [1.0e-12, 1.0e-6, 1.0e-3, 1.0e-2, 1.0e-1, 0.1]: out = extrema.h_maxima(data, h) error = diff(expected_result, out) assert error < eps
def test_extrema_float(self): """specific tests for float type""" data = np.array([[0.10, 0.11, 0.13, 0.14, 0.14, 0.15, 0.14, 0.14, 0.13, 0.11], [0.11, 0.13, 0.15, 0.16, 0.16, 0.16, 0.16, 0.16, 0.15, 0.13], [0.13, 0.15, 0.40, 0.40, 0.18, 0.18, 0.18, 0.60, 0.60, 0.15], [0.14, 0.16, 0.40, 0.40, 0.19, 0.19, 0.19, 0.60, 0.60, 0.16], [0.14, 0.16, 0.18, 0.19, 0.19, 0.19, 0.19, 0.19, 0.18, 0.16], [0.15, 0.182, 0.18, 0.19, 0.204, 0.20, 0.19, 0.19, 0.18, 0.16], [0.14, 0.16, 0.18, 0.19, 0.19, 0.19, 0.19, 0.19, 0.18, 0.16], [0.14, 0.16, 0.80, 0.80, 0.19, 0.19, 0.19, 1.0, 1.0, 0.16], [0.13, 0.15, 0.80, 0.80, 0.18, 0.18, 0.18, 1.0, 1.0, 0.15], [0.11, 0.13, 0.15, 0.16, 0.16, 0.16, 0.16, 0.16, 0.15, 0.13]], dtype=np.float32) inverted_data = 1.0 - data out = extrema.h_maxima(data, 0.003) expected_result = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=np.uint8) error = diff(expected_result, out) assert error < eps out = extrema.h_minima(inverted_data, 0.003) error = diff(expected_result, out) assert error < eps
def test_extrema_float(self): """specific tests for float type""" data = np.array([[0.10, 0.11, 0.13, 0.14, 0.14, 0.15, 0.14, 0.14, 0.13, 0.11], [0.11, 0.13, 0.15, 0.16, 0.16, 0.16, 0.16, 0.16, 0.15, 0.13], [0.13, 0.15, 0.40, 0.40, 0.18, 0.18, 0.18, 0.60, 0.60, 0.15], [0.14, 0.16, 0.40, 0.40, 0.19, 0.19, 0.19, 0.60, 0.60, 0.16], [0.14, 0.16, 0.18, 0.19, 0.19, 0.19, 0.19, 0.19, 0.18, 0.16], [0.15, 0.182, 0.18, 0.19, 0.204, 0.20, 0.19, 0.19, 0.18, 0.16], [0.14, 0.16, 0.18, 0.19, 0.19, 0.19, 0.19, 0.19, 0.18, 0.16], [0.14, 0.16, 0.80, 0.80, 0.19, 0.19, 0.19, 1.0, 1.0, 0.16], [0.13, 0.15, 0.80, 0.80, 0.18, 0.18, 0.18, 1.0, 1.0, 0.15], [0.11, 0.13, 0.15, 0.16, 0.16, 0.16, 0.16, 0.16, 0.15, 0.13]], dtype=np.float32) inverted_data = 1.0 - data out = extrema.h_maxima(data, 0.003) expected_result = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=np.uint8) error = diff(expected_result, out) assert error < eps out = extrema.h_minima(inverted_data, 0.003) error = diff(expected_result, out) assert error < eps
def accumfindcenters(self,acc, senstivity): accumMatrix = np.absolute(acc) # accumulator array sigma = 0.5 kernel = int(2*np.ceil(2*sigma)+1) accumMatrix = cv2.GaussianBlur(accumMatrix , (kernel,kernel),sigmaX=0.5) senstivity = 0.93 # default Hd = cv2.medianBlur(accumMatrix.astype('float32'),5) accumThresh = 1-senstivity suppThreshold = np.max(accumThresh- np.spacing(accumThresh),0) Hd = extrema.h_maxima(Hd, suppThreshold) bw = (local_maxima(Hd)).astype(int) label_img = label(bw, connectivity=bw.ndim) s = regionprops(label_img, intensity_image=accumMatrix) center = np.empty([len(s),2]) metric = np.empty([len(s),1]) for index,i in enumerate(s): center[index] = tuple((np.array(s[index].centroid)).astype(int)) metric[index] = Hd[tuple((np.array(s[index].centroid)).astype(int))] return center, metric
def showMaxima(self, im): fig = plt.figure() plt.imshow(im) im = self.runHistogramAbs(im) im = ndimage.gaussian_filter(im, sigma=1) im = exposure.rescale_intensity(im) h = 0.2 h_maxima = extrema.h_maxima(im, h) label_h_maxima = label(h_maxima) img = skimage.exposure.rescale_intensity(im) overlay_h = color.label2rgb(label_h_maxima, img, alpha=0.7, bg_label=0, bg_color=None) plt.imshow(overlay_h) plt.show() return
def contour_pm_watershed(contour_pm, sigma=2, h=0, tissue_mask=None, padding_mask=None, min_area=None, max_area=None): if tissue_mask is None: tissue_mask = np.ones_like(contour_pm) padded = None if padding_mask is not None and np.any(padding_mask == 0): contour_pm, padded = crop_with_padding_mask(contour_pm, padding_mask, return_mask=True) tissue_mask = crop_with_padding_mask(tissue_mask, padding_mask) maxima = peak_local_max(extrema.h_maxima(ndi.gaussian_filter( np.invert(contour_pm), sigma=sigma), h=h), indices=False, footprint=np.ones((3, 3))) maxima = label(maxima).astype(np.int32) # Passing mask into the watershed function will exclude seeds outside # of the mask, which gives fewer and more accurate segments maxima = watershed( contour_pm, maxima, watershed_line=True, mask=tissue_mask) > 0 if min_area is not None and max_area is not None: maxima = label(maxima, connectivity=1).astype(np.int32) areas = np.bincount(maxima.ravel()) size_passed = np.arange(areas.size)[np.logical_and( areas > min_area, areas < max_area)] maxima *= np.isin(maxima, size_passed) np.greater(maxima, 0, out=maxima) if padded is None: return maxima.astype(np.bool) else: padded[padded == 1] = maxima.flatten() return padded.astype(np.bool)
def test_h_maxima_float_h(self): """specific tests for h-maxima float h parameter""" data = np.array([[0, 0, 0, 0, 0], [0, 3, 3, 3, 0], [0, 3, 4, 3, 0], [0, 3, 3, 3, 0], [0, 0, 0, 0, 0]], dtype=np.uint8) h_vals = np.linspace(1.0, 2.0, 100) failures = 0 for h in h_vals: if h % 1 != 0: msgs = ['possible precision loss converting image'] else: msgs = [] with expected_warnings(msgs): maxima = extrema.h_maxima(data, h) if (maxima[2, 2] == 0): failures += 1 assert (failures == 0)
def make_labels_h5(path_to_h5, gridname, peak_min =4.0, dist_min=0.5, apply_pbc=True, extra_maxi=[]): import h5py import numpy as np from skimage.morphology import extrema import scipy.ndimage as ndi from skimage.morphology import watershed hfile = h5py.File(path_to_h5,'r') dgrid_np = np.array(hfile[gridname]) local_maxi = extrema.h_maxima(dgrid_np, peak_min) if len(extra_maxi)>0: for e in extra_maxi: local_maxi[tuple(e)] = 1 maxi_markers = ndi.label(local_maxi)[0] # Identify feature sand label those in the 3D array masked_image = dgrid_np>dist_min # Mask for the watershed # distance = ndi.distance_transform_edt(masked_image) # dgrid_np[dgrid_np<0]=0 region_labels = watershed(-dgrid_np, markers=maxi_markers, mask=masked_image.astype(np.int)) if apply_pbc: rlpbc = apply_pbc3(region_labels, local_maxi) return rlpbc, local_maxi, dgrid_np[np.where(local_maxi)] else: return region_labels, local_maxi, dgrid_np[np.where(local_maxi)]
def label_watershed(obj: np.array, maxima_threshold): """ Separate touching objects based on distance map (similar to imageJ watershed) :param obj: np.array, 0-and-1 :param maxima_threshold: threshold for identify maxima :return: seg: np.array, grey scale with different objects labeled with different numbers """ _, dis = medial_axis(obj, return_distance=True) maxima = extrema.h_maxima(dis, maxima_threshold) # maxima_threshold for Jess data = 1 # maxima_threshold for Jose data = 10 maxima_mask = binary_dilation(maxima) for i in range(6): maxima_mask = binary_dilation(maxima_mask) label_maxima = label(maxima_mask, connectivity=2) markers = label_maxima.copy() markers[obj == 0] = np.amax(label_maxima) + 1 elevation_map = sobel(obj) label_obj = segmentation.watershed(elevation_map, markers) label_obj[label_obj == np.amax(label_maxima) + 1] = 0 return label_obj
def test_extrema_float(self): "specific tests for float type" data = np.array([[0.10, 0.11, 0.13, 0.14, 0.14, 0.15, 0.14, 0.14, 0.13, 0.11], [0.11, 0.13, 0.15, 0.16, 0.16, 0.16, 0.16, 0.16, 0.15, 0.13], [0.13, 0.15, 0.40, 0.40, 0.18, 0.18, 0.18, 0.60, 0.60, 0.15], [0.14, 0.16, 0.40, 0.40, 0.19, 0.19, 0.19, 0.60, 0.60, 0.16], [0.14, 0.16, 0.18, 0.19, 0.19, 0.19, 0.19, 0.19, 0.18, 0.16], [0.15, 0.182, 0.18, 0.19, 0.204, 0.20, 0.19, 0.19, 0.18, 0.16], [0.14, 0.16, 0.18, 0.19, 0.19, 0.19, 0.19, 0.19, 0.18, 0.16], [0.14, 0.16, 0.80, 0.80, 0.19, 0.19, 0.19, 1.0, 1.0, 0.16], [0.13, 0.15, 0.80, 0.80, 0.18, 0.18, 0.18, 1.0, 1.0, 0.15], [0.11, 0.13, 0.15, 0.16, 0.16, 0.16, 0.16, 0.16, 0.15, 0.13]], dtype=np.float32) inverted_data = 1.0 - data expected_result = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=np.uint8) # test for local maxima with automatic step calculation out = extrema.local_maxima(data) error = diff(expected_result, out) assert error < eps # test for local minima with automatic step calculation out = extrema.local_minima(inverted_data) error = diff(expected_result, out) assert error < eps out = extrema.h_maxima(data, 0.003) expected_result = np.array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 1, 1, 0, 0, 0, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=np.uint8) error = diff(expected_result, out) assert error < eps out = extrema.h_minima(inverted_data, 0.003) error = diff(expected_result, out) assert error < eps
def S3NucleiSegmentationWatershed(nucleiPM, nucleiImage, logSigma, TMAmask, nucleiFilter, nucleiRegion): nucleiContours = nucleiPM[:, :, 1] nucleiCenters = nucleiPM[:, :, 0] mask = resize(TMAmask, (nucleiImage.shape[0], nucleiImage.shape[1]), order=0) > 0 if nucleiRegion == 'localThreshold': Imax = peak_local_max(extrema.h_maxima(255 - nucleiContours, logSigma[0]), indices=False) Imax = label(Imax).astype(np.int32) foregroundMask = watershed(nucleiContours, Imax, watershed_line=True) P = regionprops( foregroundMask, np.amax(nucleiCenters) - nucleiCenters - nucleiContours) prop_keys = ['mean_intensity', 'label'] def props_of_keys(prop, keys): return [prop[k] for k in keys] mean_ints, labels = np.array( Parallel(n_jobs=6)(delayed(props_of_keys)(prop, prop_keys) for prop in P)).T del P passed = np.less(mean_ints, 50) foregroundMask *= np.isin(foregroundMask, labels[passed]) np.greater(foregroundMask, 0, out=foregroundMask) foregroundMask = label(foregroundMask, connectivity=1).astype(np.int32) else: if len(logSigma) == 1: nucleiDiameter = [logSigma * 0.5, logSigma * 1.5] else: nucleiDiameter = logSigma logMask = nucleiCenters > 150 win_view_setting = WindowView(nucleiContours.shape, 2000, 500) nucleiContours = win_view_setting.window_view_list(nucleiContours) padding_mask = win_view_setting.padding_mask() mask = win_view_setting.window_view_list(mask) maxArea = (logSigma[1]**2) * 3 / 4 minArea = (logSigma[0]**2) * 3 / 4 foregroundMask = np.array( Parallel(n_jobs=6)( delayed(contour_pm_watershed)(img, sigma=logSigma[1] / 30, h=logSigma[1] / 30, tissue_mask=tm, padding_mask=m, min_area=minArea, max_area=maxArea) for img, tm, m in zip(nucleiContours, mask, padding_mask))) del nucleiContours, mask foregroundMask = win_view_setting.reconstruct(foregroundMask) foregroundMask = label(foregroundMask, connectivity=1).astype(np.int32) if nucleiFilter == 'IntPM': int_img = nucleiCenters elif nucleiFilter == 'Int': int_img = nucleiImage print(' ', datetime.datetime.now(), 'regionprops') P = regionprops(foregroundMask, int_img) def props_of_keys(prop, keys): return [prop[k] for k in keys] prop_keys = ['mean_intensity', 'area', 'solidity', 'label'] mean_ints, areas, solidities, labels = np.array( Parallel(n_jobs=6)(delayed(props_of_keys)(prop, prop_keys) for prop in P)).T del P MITh = threshold_otsu(mean_ints) minSolidity = 0.8 passed = np.logical_and.reduce( (np.greater(mean_ints, MITh), np.logical_and(areas > minArea, areas < maxArea), np.greater(solidities, minSolidity))) # set failed mask label to zero foregroundMask *= np.isin(foregroundMask, labels[passed]) np.greater(foregroundMask, 0, out=foregroundMask) foregroundMask = label(foregroundMask, connectivity=1).astype(np.int32) return foregroundMask
def buttonSave(arg): copy = arg[1] imageTemp = arg[2] filterTry = filterVar.get() if (filterTry == 1): copy = cv2.GaussianBlur(copy, (5, 5), 0) elif (filterTry == 2): copy = cv2.Canny(copy, 100, 150) elif (filterTry == 3): copy = filters.roberts(imageTemp) elif (filterTry == 4): copy = filters.sato(imageTemp) elif (filterTry == 5): copy = filters.scharr(imageTemp) elif (filterTry == 6): copy = filters.sobel(imageTemp) elif (filterTry == 7): copy = filters.unsharp_mask(copy, radius=30, amount=3) elif (filterTry == 8): #copy = filters.median(imageTemp, disk(5)) b, g, r = cv2.split(copy) b = filters.median(b, disk(5)) g = filters.median(g, disk(5)) r = filters.median(r, disk(5)) copy = cv2.merge((b, g, r)) elif (filterTry == 9): copy = filters.prewitt(imageTemp) elif (filterTry == 10): copy = filters.rank.modal(imageTemp, disk(5)) flag = 0 if (np.ndim(copy) == 2): flag = 0 else: flag = 1 if (hEsitleme.get() or hGrafik.get()): if (flag): copy = cv2.cvtColor(copy, cv2.COLOR_BGR2GRAY) if (hGrafik.get()): plt.hist(copy.ravel(), 256, [0, 256]) plt.show() if (hEsitleme.get()): copy = cv2.equalizeHist(copy) if (uzaysalVars[0].get()): reScaleRatio = float(uzaysalVarsInputs[0].get()) if (np.ndim(copy) == 3): b, g, r = cv2.split(copy) b = transform.rescale(b, reScaleRatio) g = transform.rescale(g, reScaleRatio) r = transform.rescale(r, reScaleRatio) copy = cv2.merge((b, g, r)) else: copy = transform.rescale(copy, reScaleRatio) if (uzaysalVars[1].get()): resizeY = float(uzaysalVarsInputs[1].get()) resizeX = float(uzaysalVarsInputs[2].get()) if (np.ndim(copy) == 3): b, g, r = cv2.split(copy) b = transform.resize( b, (b.shape[0] // resizeX, b.shape[1] // resizeY), anti_aliasing=True) g = transform.resize( g, (g.shape[0] // resizeX, g.shape[1] // resizeY), anti_aliasing=True) r = transform.resize( r, (r.shape[0] // resizeX, r.shape[1] // resizeY), anti_aliasing=True) copy = cv2.merge((b, g, r)) else: copy = transform.resize( copy, (copy.shape[0] // resizeX, copy.shape[1] // resizeY), anti_aliasing=True) if (uzaysalVars[2].get()): copy = transform.swirl(copy, rotation=0, strength=10, radius=120) if (uzaysalVars[3].get()): copy = transform.rotate(copy, int(uzaysalVarsInputs[3].get()), resize=True) if (uzaysalVars[4].get()): copy = copy[:, ::-1] if (yogunlukVars[0].get() or yogunlukVars[1].get()): if (yogunlukVars[0].get()): startINX = int(yogunlukVars[2].get()) finishINX = int(yogunlukVars[3].get()) copy = exposure.rescale_intensity(copy, in_range=(startINX, finishINX)) if (yogunlukVars[1].get()): startOUTX = int(yogunlukVars[4].get()) finishOUTX = int(yogunlukVars[5].get()) copy = exposure.rescale_intensity(copy, out_range=(startOUTX, finishOUTX)) morfoTry = morfVar.get() morfoGirisN = 0 if (np.ndim(copy) == 3): morfoGirisN = 1 if (morfoTry == 1): if (morfoGirisN): b, g, r = cv2.split(copy) b = morphology.area_closing(b, 128, 9) g = morphology.area_closing(g, 128, 9) r = morphology.area_closing(r, 128, 9) copy = cv2.merge((b, g, r)) else: copy = morphology.area_closing(copy) elif (morfoTry == 2): if (morfoGirisN): b, g, r = cv2.split(copy) b = morphology.area_opening(b, 128, 9) g = morphology.area_opening(g, 128, 9) r = morphology.area_opening(r, 128, 9) copy = cv2.merge((b, g, r)) else: copy = morphology.area_opening(copy) elif (morfoTry == 3): if (morfoGirisN): b, g, r = cv2.split(copy) b = morphology.erosion(b, disk(6)) g = morphology.erosion(g, disk(6)) r = morphology.erosion(r, disk(6)) copy = cv2.merge((b, g, r)) else: copy = morphology.erosion(copy, disk(6)) elif (morfoTry == 4): if (morfoGirisN): b, g, r = cv2.split(copy) b = morphology.dilation(b, disk(6)) g = morphology.dilation(g, disk(6)) r = morphology.dilation(r, disk(6)) copy = cv2.merge((b, g, r)) else: copy = morphology.dilation(copy, disk(6)) elif (morfoTry == 5): if (morfoGirisN): b, g, r = cv2.split(copy) b = morphology.opening(b, disk(6)) g = morphology.opening(g, disk(6)) r = morphology.opening(r, disk(6)) copy = cv2.merge((b, g, r)) else: copy = morphology.opening(copy, disk(6)) elif (morfoTry == 6): if (morfoGirisN): b, g, r = cv2.split(copy) b = morphology.closing(b, disk(6)) g = morphology.opening(g, disk(6)) r = morphology.opening(r, disk(6)) copy = cv2.merge((b, g, r)) else: copy = morphology.opening(copy, disk(6)) elif (morfoTry == 7): if (morfoGirisN): b, g, r = cv2.split(copy) b = morphology.white_tophat(b, disk(6)) g = morphology.white_tophat(g, disk(6)) r = morphology.white_tophat(r, disk(6)) copy = cv2.merge((b, g, r)) else: copy = morphology.white_tophat(copy, disk(6)) elif (morfoTry == 8): if (morfoGirisN): b, g, r = cv2.split(copy) b = morphology.black_tophat(b, disk(6)) g = morphology.black_tophat(g, disk(6)) r = morphology.black_tophat(r, disk(6)) copy = cv2.merge((b, g, r)) else: copy = morphology.black_tophat(copy, disk(6)) elif (morfoTry == 10): if (morfoGirisN): copy = cv2.cvtColor(copy, cv2.COLOR_BGR2GRAY) copy = exposure.rescale_intensity(copy) local_maxima = extrema.local_maxima(copy) label_maxima = measure.label(local_maxima) copy = color.label2rgb(label_maxima, copy, alpha=0.7, bg_label=0, bg_color=None, colors=[(1, 0, 0)]) elif (morfoTry == 9): if (morfoGirisN): copy = cv2.cvtColor(copy, cv2.COLOR_BGR2GRAY) copy = exposure.rescale_intensity(copy) h = 0.05 h_maxima = extrema.h_maxima(copy, h) label_h_maxima = measure.label(h_maxima) copy = color.label2rgb(label_h_maxima, copy, alpha=0.7, bg_label=0, bg_color=None, colors=[(1, 0, 0)]) arg[1] = copy arg[2] = imageTemp cv2.imshow("org", copy) cv2.waitKey(0) cv2.destroyAllWindows() """
alpha=0.7, bg_label=0, bg_color=None, colors=[(1, 0, 0)]) # We observed in the previous image, that there are many local maxima # that are caused by the noise in the image. # For this, we find all local maxima with a height of h. # This height is the gray level value by which we need to descent # in order to reach a higher maximum and it can be seen as a local # contrast measurement. # The value of h scales with the dynamic range of the image, i.e. # if we multiply the image with a constant, we need to multiply # the value of h with the same constant in order to achieve the same result. h = 0.05 h_maxima = extrema.h_maxima(img, h) label_h_maxima = label(h_maxima) overlay_h = color.label2rgb(label_h_maxima, img, alpha=0.7, bg_label=0, bg_color=None, colors=[(1, 0, 0)]) ############################################################## # GRAPHICAL OUTPUT # a new figure with 3 subplots fig, ax = plt.subplots(1, 3, figsize=(15, 5)) ax[0].imshow(img, cmap='gray')
def search_local_extremum_points_max3(self, history, x_letftop, y_lefttop, x_rightbottom, y_rightbottom): ''' 提取关键点 :param history: 预测的结果 :param x_letftop: :param y_lefttop: :param x_rightbottom: :param y_rightbottom: :return: 坐标集合,与应用的概率 ''' # for train set: t,c,h = -0.5, 50, 0.02 t_thresh = 0 # -0.5 c_thresh = 300 # 50 h_param = 0.01 # 0.02 low_prob_thresh, high_prob_thresh = CancerMapBuilder.calc_probability_threshold( history, t=t_thresh) print("low_prob_thresh = {:.4f}, high_prob_thresh = {:.4f}".format( low_prob_thresh, high_prob_thresh)) cmb = CancerMapBuilder(self._params, extract_scale=40, patch_size=256) cancer_map = cmb.generating_probability_map(history, x_letftop, y_lefttop, x_rightbottom, y_rightbottom, self._params.GLOBAL_SCALE) # cancer_map = filters.gaussian(cancer_map, sigma=0.2) h = h_param h_maxima = extrema.h_maxima(cancer_map, h, selem=square(7)) xy = np.nonzero(h_maxima) sorted_points = [] for y, x in zip(xy[0], xy[1]): prob = cancer_map[y, x] if prob > low_prob_thresh: sorted_points.append((prob, x, y)) sorted_points.sort(key=lambda x: (x[0]), reverse=True) resolution = 0.243 level = 5 Threshold = 3 * 75 / (resolution * pow(2, level) * 2) # 3 result = [] while len(sorted_points) > 0: m = sorted_points.pop(0) mx = m[1] my = m[2] mprob = m[0] tx = [mx] ty = [my] temp = [] for prob, x, y in sorted_points: dist = distance.euclidean([mx, my], [x, y]) if dist > Threshold: temp.append((prob, x, y)) else: tx.append(x) ty.append(y) mx = np.rint(np.mean(np.array(tx))).astype(np.int) my = np.rint(np.mean(np.array(ty))).astype(np.int) result.append((mprob, mx, my)) sorted_points = temp result.sort(key=lambda x: (x[0]), reverse=True) candidated = [] count = 0 for prob, x, y in result: if prob > high_prob_thresh or (prob > low_prob_thresh and count < c_thresh): x = x + x_letftop y = y + y_lefttop candidated.append({"x": 32 * x, "y": 32 * y, "prob": prob}) count += 1 return candidated
local_maxima = extrema.local_maxima(img) label_maxima = label(local_maxima) overlay = color.label2rgb(label_maxima, img, alpha=0.7, bg_label=0, bg_color=None, colors=[(1, 0, 0)]) # We observed in the previous image, that there are many local maxima # that are caused by the noise in the image. # For this, we find all local maxima with a height of h. # This height is the gray level value by which we need to descent # in order to reach a higher maximum and it can be seen as a local # contrast measurement. # The value of h scales with the dynamic range of the image, i.e. # if we multiply the image with a constant, we need to multiply # the value of h with the same constant in order to achieve the same result. h = 0.05 h_maxima = extrema.h_maxima(img, h) label_h_maxima = label(h_maxima) overlay_h = color.label2rgb(label_h_maxima, img, alpha=0.7, bg_label=0, bg_color=None, colors=[(1, 0, 0)]) ############################################################## # GRAPHICAL OUTPUT # a new figure with 3 subplots fig, ax = plt.subplots(1, 3, figsize=(15, 5)) ax[0].imshow(img, cmap='gray', interpolation='none') ax[0].set_title('Original image') ax[0].axis('off')
img = exposure.rescale_intensity(img) #extract all local maxima local_maxima = extrema.local_maxima(img) label_maxima = label(local_maxima) overlay = color.label2rgb(label_maxima, img, alpha=0.7, bg_label=0, bg_color=None, colors=[(1, 0, 0)]) #extract local maxima with certrain regional contrast h = 0.05 nb = morphology.selem.disk(radius=3) h_maxima = extrema.h_maxima(img, h, selem=nb) label_h_maxima = label(h_maxima) overlay_hr = color.label2rgb(label_h_maxima, Color_Masked, alpha=0.7, bg_label=0, bg_color=None, colors=[(1, 0, 0)]) #plot results fig, ax = plt.subplots(1, 3, figsize=(15, 5), sharex=True, sharey=True) ax[0].imshow(Color_Masked, cmap='gray', interpolation='none') ax[0].set_title('Original image') ax[0].axis('off') ax[1].imshow(overlay, interpolation='none') ax[1].set_title('Local Maxima')
def h_max_transform(img, h): h_maxima = extrema.h_maxima(img, h) label_h_maxima = label(h_maxima) label_h_maxima[label_h_maxima > 0] = 255 return label_h_maxima
# get the inputs and masks inputs = inputs[0].to(device=device)[None,:,:,:] net.eval() outputs = net(inputs) out = outputs[0, 0, :, :].numpy() # mask = masks[0, 0, :, :].numpy() array = np.where(out < 0.3, 0, out) array = out # diff = mask-array h = 0.2 h_maxima = extrema.h_maxima(array, h) label_h_maxima = label(h_maxima) overlay_h = color.label2rgb(label_h_maxima, inputs[0, 0, :, :], alpha=0.7, bg_label=0, bg_color=None, colors=[(1, 0, 0)]) coordinates = peak_local_max(array, indices=True) coordinates_h = peak_local_max(h_maxima, indices=True) fig = plt.figure(dpi=300) # ax1 = fig.add_subplot(2, 3, 1) # ax1.imshow(inputs[0, 0, :, :].detach().cpu().numpy(), cmap="gray") # # ax1.plot(coordinates[:, 1], coordinates[:, 0], 'r+', markersize=10) # ax2 = fig.add_subplot(2, 3, 2) # ax2.imshow(array, cmap="jet") # ax3 = fig.add_subplot(2, 3, 3)
def detect(img): img = np.array(img.convert('RGB')) count = 0 cell_hsvmin = (52, 88, 124 ) #Lower end of the HSV range defining the nuclei cell_hsvmax = (150, 190, 255 ) #Upper end of the HSV range defining the nuclei hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) Z = hsv.reshape((-1, 3)) #number of chanel, number of row # print(Z) #Convert to floating point 32 bit Z = np.float32(Z) # plt.hist(Z),plt.show() # histr = cv2.calcHist(Z,[0],None,[256],[0,256]) # # show the plotting graph of an image # plt.plot(histr) # plt.show() # plt.hist(Z,256,[0,256]),plt.show() # plt.scatter(Z[:,0], Z[:,1]) # plt.show() # dc=DominantColor #Define the K-means criteria, these are not too important #whenever 10 iterations of algorithm is ran, or an accuracy of epsilon = 1.0 is reached, stop the algorithm and return the answer. # Define criteria = ( type, max_iter = 10 , epsilon = 1.0 ) criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0) #Define the number of clusters to find #นับจาก histrogram มั้ง มันมี4กลุ่ม >> k=4 K = 4 #Perform the k-means transformation. What we get back are: #*Centers: The coordinates at the center of each 3-space cluster #*Labels: Numeric labels for each cluster #*Ret: A return code indicating whether the algorithm converged, &c. ret, label, center = cv2.kmeans(Z, K, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS) #Produce an image using only the center colours of the clusters center = np.uint8(center) khsv = center[label.flatten()] khsv = khsv.reshape((img.shape)) # ShowImage('K-means',khsv,'hsv') #Reshape labels for masking label = label.reshape(img.shape[0:2]) # ShowImage('K-means Labels',label,'gray') #(Distance,Label) pairs nucleus_colour = np.array([139, 106, 192]) cell_colour = np.array([130, 41, 207]) # nucleus_colour = np.array([44, 71, 100]) # cell_colour = np.array([112, 140, 171]) nuclei_label = (np.inf, -1) cell_label = (np.inf, -1) for l, c in enumerate(center): # print(l,c) dist_nuc = np.sum( np.square(c - nucleus_colour)) #Euclidean distance between colours if dist_nuc < nuclei_label[0]: nuclei_label = (dist_nuc, l) dist_cell = np.sum( np.square(c - cell_colour)) #Euclidean distance between colours if dist_cell < cell_label[0]: cell_label = (dist_cell, l) nuclei_label = nuclei_label[1] cell_label = cell_label[1] # print("Nuclei label={0}, cell label={1}".format(nuclei_label,cell_label)) #Multiply by 1 to keep image in an integer format suitable for OpenCV thresh = cv2.bitwise_or(1 * (label == nuclei_label), 1 * (label == cell_label)) thresh = np.uint8(thresh) # ShowImage('Binary',thresh,'gray') #Remove noise by eliminating single-pixel patches kernel = np.ones((3, 3), np.uint8) opening = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2) # ShowImage('Opening',opening,'gray') #Identify areas which are surely foreground fraction_foreground = 0.75 dist = cv2.distanceTransform(opening, cv2.DIST_L2, 5) ret, sure_fg = cv2.threshold(dist, fraction_foreground * dist.max(), 255, 0) # ShowImage('Distance',dist,'gray') # ShowImage('Surely Foreground',sure_fg,'gray') #Identify areas which are surely foreground h_fraction = 0.1 dist = cv2.distanceTransform(opening, cv2.DIST_L2, 5) maxima = extrema.h_maxima(dist, h_fraction * dist.max()) # print("Peaks found: {0}".format(np.sum(maxima))) #หาค่าความสูง #Dilate the maxima so we can see them maxima = cv2.dilate(maxima, kernel, iterations=2) # ShowImage('Distance',dist,'gray') # ShowImage('Surely Foreground',maxima,'gray') # Finding unknown region unknown = cv2.subtract(opening, maxima) # ShowImage('Unknown',unknown,'gray') # Marker labelling ret, markers = cv2.connectedComponents(maxima) # ShowImage('Connected Components',markers,'rgb') # Add one to all labels so that sure background is not 0, but 1 markers = markers + 1 # Now, mark the region of unknown with zero markers[unknown == np.max(unknown)] = 0 # ShowImage('markers',markers,'rgb') dist = cv2.distanceTransform(opening, cv2.DIST_L2, 5) markers = skwater(-dist, markers, watershed_line=True) # ShowImage('Watershed',markers,'rgb') imgout = img.copy() imgout[markers == 0] = [0, 0, 255] #Label the watershed_line #x = datetime.datetime.now() #st.success(x.strftime("%x")) tz = pytz.timezone('Asia/Bangkok') now1 = datetime.datetime.now(tz) month_name = 'x มกราคม กุมภาพันธ์ มีนาคม เมษายน พฤษภาคม มิถุนายน กรกฎาคม สิงหาคม กันยายน ตุลาคม พฤศจิกายน ธันวาคม'.split( )[now1.month] thai_year = now1.year + 543 time_str = now1.strftime('%H:%M:%S') st.success("%d %s %d %s" % (now1.day, month_name, thai_year, time_str)) # img.save(imgout) # cv2.imwrite('output.jpg', imgout) for l in np.unique(markers): if l == 0: #Watershed line continue if l == 1: #Background continue #For displaying individual cells #temp=khsv.copy() #temp[markers!=l]=0 #ShowImage('out',temp,'hsv') temp = label.copy() temp[markers != l] = -1 nucleus_area = np.sum(temp == nuclei_label) cell_area = np.sum(temp == cell_label) # print("nucleus_area", nucleus_area) # print("cell_area", cell_area) # file1.close() if nucleus_area / (cell_area + nucleus_area) != 0 and nucleus_area / ( cell_area + nucleus_area) != 1 and nucleus_area / ( cell_area + nucleus_area) != 0.5: # output.append(l,nucleus_area/(cell_area+nucleus_area)) # output.append('\n') st.write("N/C ratio is ", nucleus_area / (cell_area + nucleus_area)) count = count + 1 # st.markdown("Nucleus fraction for cell {0} is {1}".format(l,nucleus_area/(cell_area+nucleus_area))) # test2.append(nucleus_area/(cell_area+nucleus_area)) # output.append("Nucleus fraction for cell {0} is {1}".format(l,nucleus_area/(cell_area+nucleus_area))) # test1 = "\n".join(output) # output = "\n".join(output) # print("Nucleus fraction for cell {0} is {1} ".format(l,nucleus_area/(cell_area+nucleus_area))) # print(*output, sep = "\n") st.write("Sum of cell is ", count) return img
def evaluate(model, eval_loader, dist_threshold=3): device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") runnning_dice_vec = 0 runnning_prec_vec = 0 runnning_rec_vec = 0 dice_vec = [] model.eval() for i, (image, mask, name, x, y) in enumerate(eval_loader): name = name[0] image = image[0].to(device=device)[None, :, :, :] with torch.no_grad(): outputs = model(image) out = outputs[0, 0, :, :].cpu().numpy() array = np.where(out < 0.3, 0, out) h = 0.3 h_maxima = extrema.h_maxima(array, h) label_h_maxima = label(h_maxima) coordinates = peak_local_max(label_h_maxima, indices=True) # fig = plt.figure(dpi=300) # ax1 = fig.add_subplot(1, 3, 1) # ax1.imshow(image[0, 0, :, :].detach().cpu().numpy(), cmap="gray") # ax1.plot(coordinates[:, 1], coordinates[:, 0], 'r+', markersize=10) # ax2 = fig.add_subplot(1, 3, 2) # ax2.imshow(outputs[0, 0, :, :].detach().cpu().numpy(), cmap="gray") # ax3 = fig.add_subplot(1, 3, 3) # # ax3.imshow(inputs[0, 0, :, :].detach().cpu().numpy(), cmap="gray") # # ax3.imshow(outputs[0, 0, :, :].detach().cpu().numpy(), cmap="jet", alpha=0.3) # ax3.imshow(array) # plt.show() gt_x = x gt_y = y pred_x = coordinates[:, 1] pred_y = coordinates[:, 0] # fig = plt.figure(dpi=300) # ax1 = fig.add_subplot(1, 1, 1) # ax1.imshow(image[0, 0, :, :].detach().cpu().numpy(), cmap="gray") # ax1.plot(gt_x, gt_y, 'g+', linewidth=3, markersize=12) # ax1.plot(pred_x, pred_y, 'm+', linewidth=3, markersize=12) # plt.show() dist_matrix = np.zeros((len(gt_x), len(pred_x))) for row, (g_x, g_y) in enumerate(zip(gt_x, gt_y)): for col, (p_x, p_y) in enumerate(zip(pred_x, pred_y)): x = abs(g_x - p_x) y = abs(g_y - p_y) dist_matrix[row, col] = math.sqrt((x * x) + (y * y)) min_dists = np.amin(dist_matrix, axis=0) tp = 0 fp = 0 for dist in min_dists: if dist <= dist_threshold: tp += 1 else: fp += 1 tp = len(gt_x) if tp > len(gt_x) else tp fn = len(gt_x) - tp if (tp + fp) == 0: precision = 0 else: precision = tp / (tp + fp) recall = tp / (tp + fn) dice = (2 * tp) / (2 * tp + fp + fn) runnning_dice_vec += dice runnning_prec_vec += precision runnning_rec_vec += recall dice_vec.append(dice) print( f"{name}, TP: {tp}, FP: {fp}, FN: {fn}, precision: {precision}, recall: {recall}, dice: {dice}" ) # print(f"Iteration: {i} of {len(eval_loader)}, image: {name}") # dice_vec.append(runnning_dice_vec / len(eval_loader)) # prec_vec.append(runnning_prec_vec / len(eval_loader)) # rec_vec.append(runnning_rec_vec / len(eval_loader)) prec_result = runnning_prec_vec / len(eval_loader) rec_result = runnning_rec_vec / len(eval_loader) dice_result = runnning_dice_vec / len(eval_loader) return prec_result, rec_result, dice_result, dice_vec
img = exposure.rescale_intensity(img) #extract local maxima local_maxima = extrema.local_maxima(img_gs_inv) label_maxima = label(local_maxima) overlay = color.label2rgb(label_maxima, img_gs_inv, alpha=0.7, bg_label=0, bg_color=None, colors=[(1, 0, 0)]) #local maxima with certrain contrast h = 0.05 ding = morphology.selem.disk(radius=3) h_maxima = extrema.h_maxima(img, h, selem=ding) label_h_maxima = label(h_maxima) overlay_h = color.label2rgb(label_h_maxima, img, alpha=0.7, bg_label=0, bg_color=None, colors=[(1, 0, 0)]) # a new figure with 3 subplots fig, ax = plt.subplots(1, 3, figsize=(15, 5), sharex=True, sharey=True) ax[0].imshow(Color_Masked, cmap='gray', interpolation='none') ax[0].set_title('Original image') ax[0].axis('off')
#binar_data=img_as_float(binar_data) label_data = label(binar_data) #označení buněk v masce #plt.imshow(label_data,cmap=plt.cm.nipy_spectral) output = np.load('/Users/betyadamkova/Desktop/final/model 8/output/' + 'output' + str(it) + '.npy') output = output[0, 0, :, :] inverse_output = util.invert(output) #inverzní distanšní mapa binar_output = output > 1.3 binar_output = remove_small_holes(remove_small_objects(binar_output, 15), 12) #plt.imshow(inverse_output,cmap="gray") ################### marker controlled watershed h = 2 #h= minimální výška extrahovaných maxim h_maxima = extrema.h_maxima(output, h) #nalezení středu buněk marker = label(h_maxima) #označení stredu buněk #plt.imshow(h_maxima,cmap="gray") labels = watershed( inverse_output, marker, mask=binar_output ) #vstup do funkce: inverní distanční mapa, označené středy, binární #plt.imshow(labels,cmap=plt.cm.nipy_spectral) ################ random walker segmentation h = 2 h_maxima = extrema.h_maxima(output, h) #středy buněk marker2 = label(h_maxima) #označení buněk marker2[~binar_output] = -1 #bunky=0, okoli=-1, středy buněk označené #plt.imshow(marker2,cmap="gray") if (np.amax(marker2)).astype( np.int