def example_nodule(pt): # logging.info('Running: example_nodule (MorphGAC)...') # Load the image. # 用quan完之後的圖用會很糟 img = imread(OUTPUT_CUTHIST) / 255.0 # img2為背景圖 img2 = imread(OUTPUT_BLACK) / 255.0 # g(I) gimg = ms.inverse_gaussian_gradient(img, alpha=1000, sigma=5.48) # Initialization of the level-set. init_ls = ms.circle_level_set(img.shape, pt, 15) # Callback for visual plotting callback = visual_callback_2d(img2) # MorphGAC. ms.morphological_geodesic_active_contour(gimg, iterations=45, init_level_set=init_ls, smoothing=1, threshold=0.29, balloon=1, iter_callback=callback)
def test_morphsnakes_incorrect_image_shape(): img = np.zeros((10, 10, 3)) ls = np.zeros((10, 9)) with pytest.raises(ValueError): morphological_chan_vese(img, iterations=1, init_level_set=ls) with pytest.raises(ValueError): morphological_geodesic_active_contour(img, iterations=1, init_level_set=ls)
def find_contour(img): img = img/255 gimg = ms.inverse_gaussian_gradient(img, alpha=1000, sigma=5.48) init_ls = ms.circle_level_set(img.shape, (100, 126), 20) callback = visual_callback_2d(img) ms.morphological_geodesic_active_contour(gimg, iterations=45, init_level_set=init_ls, smoothing=1, threshold=0.31, balloon=1, iter_callback=callback)
def moneyImage(image): inverseGaussianGradient = morphsnakes.inverse_gaussian_gradient(image) initLevelSet = np.zeros(image.shape, dtype=np.int8) initLevelSet[10:-10, 10:-10] = 1 morphsnakes.morphological_geodesic_active_contour( inverseGaussianGradient, iterations=230, init_level_set=initLevelSet, smoothing=20, threshold=0.69, balloon=-1, iter_callback=plot_2d(image))
def example_tiger(): imgage_color = imread(PATH_IMG_TIGER) / 255.0 img = rgb2gray(imgage_color) gradient_inverse = ms.inverse_gaussian_gradient(img, alpha=1000, sigma=2) init_ls = ms.create_circle(img.shape, None, 150) callback = visual_callback_2d(imgage_color) ms.morphological_geodesic_active_contour(gradient_inverse, iterations=150, init_level_set=init_ls, smoothing=2, threshold=0.3, balloon=-1, iter_callback=callback)
def example_trefle(): img = imread(PATH_IMG_TREFLE)[..., 0] / 255.0 gradient_inverse = ms.inverse_gaussian_gradient(img, alpha=1000, sigma=5.48) init_ls = ms.create_circle(img.shape, None, 20) callback = visual_callback_2d(img) ms.morphological_geodesic_active_contour(gradient_inverse, iterations=100, init_level_set=init_ls, smoothing=1, threshold=0.32, balloon=1, iter_callback=callback)
def seastarImage(image, imageRgp): inverseGaussianGradient = morphsnakes.inverse_gaussian_gradient(image, alpha=1000, sigma=2) initLevelSet = morphsnakes.circle_level_set(image.shape, center=(163, 137), radius=135) morphsnakes.morphological_geodesic_active_contour( inverseGaussianGradient, iterations=150, init_level_set=initLevelSet, smoothing=20, threshold=0.3, balloon=-1, iter_callback=plot_2d(imageRgp))
def seaImg(image): inverseGaussianGradient = morphsnakes.inverse_gaussian_gradient(image, alpha=1000, sigma=5.48) initLevelSet = morphsnakes.circle_level_set(image.shape, center=(100, 126), radius=30) morphsnakes.morphological_geodesic_active_contour( inverseGaussianGradient, iterations=65, init_level_set=initLevelSet, smoothing=20, threshold=0.31, balloon=1, iter_callback=plot_2d(image))
def test_init_level_sets(): image = np.zeros((6, 6)) checkerboard_ls = morphological_chan_vese(image, 0, 'checkerboard') checkerboard_ref = np.array([[0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1], [1, 1, 1, 1, 1, 0]], dtype=np.int8) circle_ls = morphological_geodesic_active_contour(image, 0, 'circle') circle_ref = np.array([[0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0], [0, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 0]], dtype=np.int8) ellipsoid_ls = morphological_chan_vese(np.zeros((7, 9)), 0, 'ellipsoid') ellipsoid_ref = np.array( [[0, 0, 1, 1, 1, 1, 1, 0, 0], [0, 1, 1, 1, 1, 1, 1, 1, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 1, 1, 0, 0]], dtype=np.uint8 ) assert_array_equal(checkerboard_ls, checkerboard_ref) assert_array_equal(circle_ls, circle_ref) assert_array_equal(ellipsoid_ls, ellipsoid_ref)
def make_acwe(patch: Patch, params: dict): """ Active Contour (Float layer -> Float layer) """ from skimage import exposure edge_map = 1.0 - patch.image_layers["Main"] edge_map -= np.min(edge_map) edge_map = edge_map / np.max(edge_map) # edge_map = exposure.adjust_sigmoid(edge_map, cutoff=1.0) logger.debug("Calculating ACWE") import morphsnakes as ms seg1 = ms.morphological_geodesic_active_contour( edge_map, iterations=params["iterations"], init_level_set=patch.image_layers["total_mask"], smoothing=params["smoothing"], threshold=params["threshold"], balloon=params["balloon"], ) outer_mask = ((seg1 * 1.0) > 0) * 2.0 # inner_mask = ((seg2 * 1.0) > 0) * 1.0 # outer_mask = outer_mask * (1.0 - inner_mask) # anno = outer_mask + inner_mask patch.image_layers["acwe"] = outer_mask # show_images([outer_mask[outer_mask.shape[0] // 2, :]], figsize=(12, 12)) return patch
def test_morphsnakes_simple_shape_geodesic_active_contour(): img = np.float_(circle_level_set((11, 11), (5, 5), 3.5)) gimg = inverse_gaussian_gradient(img, alpha=10.0, sigma=1.0) ls = circle_level_set(img.shape, (5, 5), 6) ref = 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, 0, 0, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 1, 1, 1, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=np.int8) gac_ls = morphological_geodesic_active_contour(gimg, iterations=10, init_level_set=ls, balloon=-1) assert_array_equal(gac_ls, ref) assert gac_ls.dtype == np.int8
def gac2d(img, coord, iterations, smoothing, balloon, threshold): print('Running: snake_2d (MorphGAC)...') range_img = img[:, :, coord[0]] range_init_ls = ms.circle_level_set(range_img.shape, (coord[2], coord[1]), 5) range_gimage = inverse_gaussian_gradient(range_img) range_ls = ms.morphological_geodesic_active_contour( range_gimage, iterations=iterations, init_level_set=range_init_ls, smoothing=smoothing, balloon=balloon, threshold=threshold) # save_img(range_img, range_ls, "gac_2d_y_slice") slices = [] i = 0 for row in range_ls: for x in row: if x == 1: slices.append([i, middle_of_line(row)]) break i += 1 middle = int((slices[-1][0] + slices[0][0]) / 2) result = np.zeros(img.shape, dtype=np.uint8) for line in slices: image_part = img[line[0]] init_ls = ms.circle_level_set(image_part.shape, (line[1], coord[0]), 5) gimage = inverse_gaussian_gradient(image_part) ls = ms.morphological_geodesic_active_contour(gimage, iterations=iterations, init_level_set=init_ls, smoothing=smoothing, balloon=balloon, threshold=threshold) result[line[0]] = ls # if i == middle: # save_img(image_part, ls, "gac_2d_slice") return result
def example_coins(): logging.info('Running: example_coins (MorphGAC)...') # Load the image. img = imread(PATH_IMG_COINS) / 255.0 # g(I) gimg = ms.inverse_gaussian_gradient(img) # Manual initialization of the level set init_ls = np.zeros(img.shape, dtype=np.int8) init_ls[10:-10, 10:-10] = 1 # Callback for visual plotting callback = visual_callback_2d(img) # MorphGAC. ms.morphological_geodesic_active_contour(gimg, 230, init_ls, smoothing=1, threshold=0.69, balloon=-1, iter_callback=callback)
def example_nodule(): logging.info('Running: example_nodule (MorphGAC)...') # Load the image. img = imread(PATH_IMG_NODULE)[..., 0] / 255.0 # g(I) gimg = ms.inverse_gaussian_gradient(img, alpha=1000, sigma=5.48) # Initialization of the level-set. init_ls = ms.circle_level_set(img.shape, (100, 126), 20) # Callback for visual plotting callback = visual_callback_2d(img) # MorphGAC. ms.morphological_geodesic_active_contour(gimg, iterations=45, init_level_set=init_ls, smoothing=1, threshold=0.31, balloon=1, iter_callback=callback)
def example_starfish(): logging.info('Running: example_starfish (MorphGAC)...') # Load the image. imgcolor = imread(PATH_IMG_STARFISH) / 255.0 img = rgb2gray(imgcolor) # g(I) gimg = ms.inverse_gaussian_gradient(img, alpha=1000, sigma=2) # Initialization of the level-set. init_ls = ms.circle_level_set(img.shape, (163, 137), 135) # Callback for visual plotting callback = visual_callback_2d(imgcolor) # MorphGAC. ms.morphological_geodesic_active_contour(gimg, iterations=100, init_level_set=init_ls, smoothing=2, threshold=0.3, balloon=-1, iter_callback=callback)
def test_morphsnakes_black(): img = np.zeros((11, 11)) ls = circle_level_set(img.shape, (5, 5), 3) ref_zeros = np.zeros(img.shape, dtype=np.int8) ref_ones = np.ones(img.shape, dtype=np.int8) acwe_ls = morphological_chan_vese(img, iterations=6, init_level_set=ls) assert_array_equal(acwe_ls, ref_zeros) gac_ls = morphological_geodesic_active_contour(img, iterations=6, init_level_set=ls) assert_array_equal(gac_ls, ref_zeros) gac_ls2 = morphological_geodesic_active_contour(img, iterations=6, init_level_set=ls, balloon=1, threshold=-1, smoothing=0) assert_array_equal(gac_ls2, ref_ones) assert acwe_ls.dtype == gac_ls.dtype == gac_ls2.dtype == np.int8
def gac3d(img, coord, iterations, smoothing, balloon, threshold): print('Running: snake_3d (MorphGAC)...') init_ls = ms.circle_level_set(img.shape, (coord[2], coord[1], coord[0]), 5) gimage = inverse_gaussian_gradient(img) ls = ms.morphological_geodesic_active_contour(gimage, iterations=iterations, init_level_set=init_ls, smoothing=smoothing, balloon=balloon, threshold=threshold) return ls
def example_tumor(): logging.info('Running: example_tumor (MorphGAC)...') # Load the image. #img = imread('images/project_2乳腺肿瘤视频.avi_000000.000.png')[..., 0] / 255.0 img = imread('images/project_2乳腺肿瘤视频.avi_000004.850.png')[..., 0] / 255.0 # g(I) gimg = ms.inverse_gaussian_gradient(img, alpha=1000, sigma=10) # Initialization of the level-set. init_ls = ms.circle_level_set(img.shape, (274, 501), 20) # Callback for visual plotting callback = visual_callback_2d(img) # MorphGAC. ms.morphological_geodesic_active_contour(gimg, iterations=160, init_level_set=init_ls, smoothing=1, threshold=0.45, balloon=1, iter_callback=callback)
def getContours(self,iterations,threshold=0.69): # Morphological GAC image = img_as_float(self.image) gimage = inverse_gaussian_gradient(image) # Initial level set init_ls = np.zeros(image.shape, dtype=np.int8) init_ls[10:-10, 10:-10] = 1 # List with intermediate results for plotting the evolution evolution = [] callback = self.store_evolution_in(evolution) ls = morphological_geodesic_active_contour(gimage, iterations, init_ls, smoothing=1, balloon=-1, threshold=threshold, iter_callback=callback) # before returning the snakes, put them in the event self.contours = ls return ls
def test_init_level_sets(): image = np.zeros((6, 6)) checkerboard_ls = morphological_chan_vese(image, 0, 'checkerboard') checkerboard_ref = np.array([[0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1], [1, 1, 1, 1, 1, 0]], dtype=np.int8) circle_ls = morphological_geodesic_active_contour(image, 0, 'circle') circle_ref = np.array([[0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0], [0, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1], [0, 1, 1, 1, 1, 1], [0, 0, 1, 1, 1, 0]], dtype=np.int8) assert_array_equal(checkerboard_ls, checkerboard_ref) assert_array_equal(circle_ls, circle_ref)
def morph_snakes_segmentation(snapshot, start_point: Tuple[int, int], start_radius: int, num_iterations: int, z=None): """ Now only works with 2D image, thus always set z for now # TODO: do for 3D snapshot """ assert snapshot.ndim == 3 img = snapshot[z] # get the gaussian gradient for higher contrast gimg = ms.inverse_gaussian_gradient(img, alpha=5.0, sigma=5.0) # level_set is the starting level_set = ms.circle_level_set(img.shape, start_point, start_radius) mask = ms.morphological_geodesic_active_contour(gimg.astype('float64'), num_iterations, level_set) # repeat the 2D mask so that it is the same size as the image mask = np.repeat(mask[np.newaxis, :, :], snapshot.shape[0], axis=0) return mask
########## # b. Use morphsnakes to segment the objects in the image. # Create the mask as shown in 'wks3_1_b.jpg'. kernel = np.ones((5,5),np.uint8) noiserem = cv2.morphologyEx(np.uint8(imgcolor), cv2.MORPH_OPEN, kernel) cv2plt(noiserem) gray = cv2.cvtColor(noiserem,cv2.COLOR_BGR2GRAY) cv2plt(gray) gray.shape gray01 = gray/255.0 invg = ms.inverse_gaussian_gradient(gray01, alpha=700, sigma=3) ls0 = ms.circle_level_set(gray01.shape, (200, 250), 250) callback = ms.visual2d(cv2.cvtColor(imgcolor,cv2.COLOR_BGR2RGB)) lsf = ms.morphological_geodesic_active_contour(invg, iterations=500, init_level_set=ls0, smoothing=1, threshold=0.5, balloon=-1, iter_callback=callback) cv2plt(lsf*255)
gimg = ms.inverse_gaussian_gradient(img, alpha=1000, sigma=2) init_ls = np.zeros(img.shape, dtype=np.int8) cv2.fillPoly( init_ls, np.array([np.array(refPt, dtype=np.int32)], dtype=np.int32), 255) # Callback for visual plotting callback = visual_callback_2d(imgcolor) # MorphGAC. final_level_set = ms.morphological_geodesic_active_contour( gimg, iterations=10000, init_level_set=init_ls, smoothing=3, threshold=0.4, balloon=-1, iter_callback=callback) plt.close('all') plt.imsave("contour_images/output.png", final_level_set) # np.set_printoptions(threshold='nan') mask = np.array(final_level_set, dtype=np.uint8) * 255 # cv2.imshow("Final Mask", final_level_set * 255.) # cv2.waitKey(0) input_image = imread(args['image'])
startTime = time.time() #np.hstack((frameLeft, frameRight))#在水平方向上拼接两帧图片 while (cap.isOpened()): ret, frame = cap.read() if frame is None: break frame = frame[132:600, 191:794] frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) #开始处理 gimg = ms.inverse_gaussian_gradient(frame, alpha=1000, sigma=5.48) init_ls = ms.circle_level_set(frame.shape, (100, 126), 20) callback = visual_callback_2d(frame) ms.morphological_geodesic_active_contour(gimg, iterations=45, init_level_set=init_ls, smoothing=1, threshold=0.31, balloon=1, iter_callback=callback) ## scharrx=cv2.Scharr(frame,cv2.CV_64F,dx=1,dy=0) ## scharrx=cv2.convertScaleAbs(scharrx) ## scharry=cv2.Scharr(frame,cv2.CV_64F,dx=0,dy=1) ## scharry=cv2.convertScaleAbs(scharry) ## processedFrame=cv2.addWeighted(scharrx,0.5,scharry,0.5,0) ## ret, binary = cv2.threshold(processedFrame,127,255,cv2.THRESH_BINARY) ## contours, hierarchy = cv2.findContours(binary,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE) ## cv2.drawContours(processedFrame,contours,-1,(0,0,255),3) ## processedFrame=cv2.adaptiveThreshold(frame,255,\ ## cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,3,5)