def test_circle_perimeter_andres(): img = np.zeros((15, 15), 'uint8') rr, cc = circle_perimeter(7, 7, 0, method='andres') img[rr, cc] = 1 assert(np.sum(img) == 1) assert(img[7][7] == 1) img = np.zeros((17, 15), 'uint8') rr, cc = circle_perimeter(7, 7, 7, method='andres') img[rr, cc] = 1 img_ = np.array( [[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 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, 0]] ) assert_array_equal(img, img_)
def test_circle_perimeter_andres(): img = np.zeros((15, 15), "uint8") rr, cc = circle_perimeter(7, 7, 0, method="andres") img[rr, cc] = 1 assert np.sum(img) == 1 assert img[7][7] == 1 img = np.zeros((17, 15), "uint8") rr, cc = circle_perimeter(7, 7, 7, method="andres") img[rr, cc] = 1 img_ = np.array( [ [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0], [0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1], [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0], [0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 1, 1, 1, 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, 0], ] ) assert_array_equal(img, img_)
def test_circle_perimeter_bresenham_shape(): img = np.zeros((15, 20), 'uint8') rr, cc = circle_perimeter(7, 10, 9, method='bresenham', shape=(15, 20)) img[rr, cc] = 1 shift = 5 img_ = np.zeros((15 + 2 * shift, 20), 'uint8') rr, cc = circle_perimeter(7 + shift, 10, 9, method='bresenham', shape=None) img_[rr, cc] = 1 assert_array_equal(img, img_[shift:-shift, :])
def show_matching(img, img2, matching): print "matching..." ip_match = build_match_dic(img, img2, matching) print "Constructing intermediate image..." padding = 5 #padding around the edges bar = np.ndarray((img.shape[0], 5)) bar.fill(1.0) viewer = ImageViewer(img) viewer.show() img3 = np.column_stack((img, bar, img2)) viewer = ImageViewer(img3) viewer.show() img3 = img_as_ubyte(img3) viewer = ImageViewer(img3) viewer.show() img3 = np.pad(img3, pad_width=padding, mode='constant', constant_values=(0)) viewer = ImageViewer(img3) viewer.show() print "Drawing lines..." colimg = color.gray2rgb(img3) for k,v in random.sample(ip_match.items(), int(float(len(ip_match.keys()))*0.005)): #Choose a random colour: col = [random.randint(0,255),random.randint(0,255),random.randint(0,255)] #Calculate coordinates after padding: x1 = k[0]+padding y1 = k[1]+padding x2 = v[0]+padding y2 = v[1] + img.shape[1]+bar.shape[1]+padding #Draw the points in both images: rr, cc = circle_perimeter(x1, y1, 3) colimg[rr, cc] = col rr, cc = circle_perimeter(x2, y2, 3) colimg[rr, cc] = col #Draw a line between the points: rr, cc = line(x1,y1,x2,y2) colimg[rr, cc] = col #Show the result: viewer = ImageViewer(colimg) viewer.show()
def circle_markers(blobs, pic_shape): '''Return array with circles around foci found''' markers_rad = np.zeros(pic_shape, dtype = np.bool) x_max, y_max = pic_shape for blob in blobs: x, y, r = blob r = r*2 rr, cc = circle_perimeter(x, y, np.round(r).astype(int)) rr_new, cc_new = [], [] for x_c,y_c in zip(rr,cc): if (x_c >= 0) and (x_c < x_max) and (y_c >= 0) and (y_c < y_max): rr_new.append(x_c) cc_new.append(y_c) markers_rad[rr_new, cc_new] = True selem = np.array([0,1,0,1,1,1,0,1,0], dtype=bool).reshape((3,3)) for i in range(4): markers_rad = binary_dilation(markers_rad, selem) return markers_rad
def test_circles2(): data = np.memmap("E:\\guts_tracking\\data\\fish202_aligned_masked_8bit_150x200x440.raw", dtype='uint8', shape=(440,200,150)).copy() i = 157 hough_radii = np.arange(10, 100, 10) edges = feature.canny(data[i], sigma=3.0, low_threshold=0.4, high_threshold=0.8) hough_res = hough_circle(edges, hough_radii) centers = [] accums = [] radii = [] for radius, h in zip(hough_radii, hough_res): peaks = feature.peak_local_max(h) centers.extend(peaks) accums.extend(h[peaks[:, 0], peaks[:, 1]]) radii.extend([radius] * len(peaks)) image = ski.color.gray2rgb(data[i]) for idx in np.argsort(accums)[::-1][:5]: center_x, center_y = centers[idx] radius = radii[idx] cx, cy = circle_perimeter(center_y, center_x, radius) if max(cx) < 150 and max(cy) < 200: image[cy, cx] = (220, 20, 20) plt.imshow(image, cmap='gray') plt.show()
def animate(i): print 'Frame %d' % i plt.title('Frame %d' % i) image = data[i] hough_radii = np.arange(10, 100, 10) edges = feature.canny(data[i], sigma=3.0, low_threshold=0.4, high_threshold=0.8) hough_res = hough_circle(edges, hough_radii) centers = [] accums = [] radii = [] for radius, h in zip(hough_radii, hough_res): peaks = feature.peak_local_max(h) centers.extend(peaks) accums.extend(h[peaks[:, 0], peaks[:, 1]]) radii.extend([radius] * len(peaks)) image = ski.color.gray2rgb(data[i]) for idx in np.argsort(accums)[::-1][:5]: center_x, center_y = centers[idx] radius = radii[idx] cx, cy = circle_perimeter(center_y, center_x, radius) if max(cx) < 150 and max(cy) < 200: image[cy, cx] = (220, 20, 20) im.set_data(image) return im,
def compute_singularity_measure(gradients): """ Compute singularity measure of data """ # precompute closed curve coordinates circle_rad = 5 grad_dim = gradients[0].shape closed_curves = np.empty(grad_dim, dtype=(list, list)) for j in range(grad_dim[1]): for i in range(grad_dim[0]): rr, cc = circle_perimeter( i, j, circle_rad, method='andres', shape=grad_dim ) closed_curves[i, j] = (rr, cc) # find singularities singularities = [] for grad in gradients: width, height = grad.shape singularity = np.empty((width, height)) for j in range(height): for i in range(width): res = np.sum(grad[closed_curves[i, j]]) singularity[i, j] = res singularity = np.array(singularity) singularities.append(singularity) return np.array(singularities)
def gen_ring_mask(votes, img, y0, x0, r0): import skimage.draw as draw #rad = np.sum(np.sum(votes[:,y0-1:y0+2,x0-1:x0+2], axis=1), axis=1) rad = votes[:, y0, x0] peaks = np.where(np.r_[False, rad[1:] > rad[:-1]] & np.r_[rad[:-1] > rad[1:], False] & (rad >= 0.2*rad.max())) peaks = peaks[0] coeffs = [] xx = range(len(rad)) flag = np.zeros(len(rad), dtype='uint8') # fit guassian peak for p in peaks: if p > 1.3*r0: break yy = np.copy(rad) yy[:p-3] = 0 yy[p+4:] = 0 cc = fit_gauss(xx, yy, rad[p], p, 2) flag[np.floor(cc[1]-cc[2]):np.ceil(cc[1]+cc[2])+1] = 1 coeffs.append(cc) #print flag, coeffs # create image mask mask = np.zeros(img.shape, dtype='uint8') for _r, _f in enumerate(flag): if _f == 1: _y, _x = draw.circle_perimeter(y0, x0, _r, 'andres') mask[_y, _x] = 1 return mask
def onclick(self,event): if event.inaxes==ax: if event.button==1: if np.sum(MASKs[self.ind])==0: cx, cy = circle_perimeter(int(event.ydata), int(event.xdata), 3) MASKs[self.ind][cx,cy] = (220, 80, 20, 1) original_image = np.copy(MASKs[self.ind][:,:,3]) chull = convex_hull_image(original_image) MASKs[self.ind][chull,:] = (255, 0, 0, .4) ax.cla() data = areaFile.attrs['ROI_patches'][:,:,self.ind] ax.imshow(data,cmap='binary_r') ax.imshow(MASKs[self.ind]) elif event.button==3: MASKs[self.ind] = np.zeros(MASKs[self.ind].shape) data = areaFile.attrs['ROI_patches'][:,:,self.ind] ax.cla() ax.imshow(data,cmap='binary_r') ax.imshow(MASKs[self.ind])
def hugh_circle_detection(image): # Load picture and detect edges edges = canny(image, sigma=3, low_threshold=10, high_threshold=50) fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(5, 2)) # Detect two radii hough_radii = np.arange(15, 30, 2) hough_res = hough_circle(edges, hough_radii) centers = [] accums = [] radii = [] for radius, h in zip(hough_radii, hough_res): # For each radius, extract two circles num_peaks = 2 peaks = peak_local_max(h, num_peaks=num_peaks) centers.extend(peaks) accums.extend(h[peaks[:, 0], peaks[:, 1]]) radii.extend([radius] * num_peaks) # Draw the most prominent 5 circles image = color.gray2rgb(image) for idx in np.argsort(accums)[::-1][:5]: center_x, center_y = centers[idx] radius = radii[idx] cx, cy = circle_perimeter(center_y, center_x, radius) image[cy, cx] = (220, 20, 20) ax.imshow(image, cmap=plt.cm.gray) plt.show()
def draw_keypoints(img, keypoints, draw_prob): """Draws for each keypoint a circle (roughly matching the sigma of the scale) with a line for the orientation. Args: img The image to which to add the keypoints (gets copied) keypoints The keypoints to draw draw_prob Probability of drawing a keypoint (the lower the less keypoints are drawn) Returns: Image with keypoints""" height, width = img.shape img = np.copy(img) # convert from grayscale image to RGB so that keypoints can be drawn in red img = img[:, :, np.newaxis] img = np.repeat(img, 3, axis=2) for (y, x), orientation, scale_idx, scale_size, kp_type in keypoints: if draw_prob < 1.0 and random.random() <= draw_prob: # draw the circle radius = int(scale_size) rr, cc = draw.circle_perimeter(y, x, radius, shape=img.shape) img[rr, cc, 0] = 1.0 img[rr, cc, 1:] = 0 # draw orientation orientation = util.quantize(orientation, [-135, -90, -45, 0, 45, 90, 135, 180]) x_start = x y_start = y if orientation == 0: x_end = x + radius y_end = y elif orientation == 45: x_end = x + radius*(1/math.sqrt(2)) y_end = y + radius*(1/math.sqrt(2)) elif orientation == 90: x_end = x y_end = y + radius elif orientation == 135: x_end = x - radius*(1/math.sqrt(2)) y_end = y - radius*(1/math.sqrt(2)) elif orientation == 180: x_end = x - radius y_end = y elif orientation == -135: x_end = x - radius*(1/math.sqrt(2)) y_end = y - radius*(1/math.sqrt(2)) elif orientation == -90: x_end = x y_end = y - radius elif orientation == -45: x_end = x + radius*(1/math.sqrt(2)) y_end = y - radius*(1/math.sqrt(2)) x_end = np.clip(x_end, 0, width-1) y_end = np.clip(y_end, 0, height-1) rr, cc = draw.line(int(y_start), int(x_start), int(y_end), int(x_end)) img[rr, cc, 0] = 1.0 img[rr, cc, 1:] = 0 img = np.clip(img, 0, 1.0) return img
def quantify_yeast_growth(input_filename, annotation_filename, profile_filename): downscaled = load_and_downscale(input_filename) annotation = AnnotatedImage.from_grayscale(downscaled) circle = fit_central_circle(downscaled) circle_coords = circle_perimeter(*circle) annotation[circle_coords] = 0, 255, 0 x, y, r = circle center = (x, y) xdim, ydim, = downscaled.shape line_length = ydim - y mean_profile_line = find_mean_profile_line(downscaled, annotation, center, -math.pi/4, math.pi/4, line_length) record_line_profile(profile_filename, mean_profile_line) with open(annotation_filename, 'wb') as f: f.write(annotation.png())
def remove_deep_points(self, CIRCLE_RADIUS = 5, MINIMUM_BOUNDARY = 70): for point in self.POINTS_initial: segments = [] circle_x, circle_y = circle_perimeter(point[0],point[1],CIRCLE_RADIUS) circle_points = np.array(list(sorted(set(zip(circle_x,circle_y))))) sortedpoints = np.empty([len(circle_points), 2], dtype=int) test1 = circle_points[circle_points[:,0] == point[0] - CIRCLE_RADIUS] start = len(test1) end = len_cpoints = len(sortedpoints) sortedpoints[0:start] = test1 for x in xrange(point[0] - CIRCLE_RADIUS + 1, point[0] + CIRCLE_RADIUS): test1 = circle_points[circle_points[:,0] == x] testlen = len(test1) if x <= point[0]: sortedpoints[start:start+testlen/2] = test1[testlen/2:] sortedpoints[end-testlen/2:end] = test1[:testlen/2] else: sortedpoints[start:start+testlen/2] = test1[testlen/2:][::-1] sortedpoints[end-testlen/2:end] = test1[:testlen/2][::-1] start += testlen/2 end -= testlen/2 test1 = circle_points[circle_points[:,0] == point[0] + CIRCLE_RADIUS] sortedpoints[start:start + len(test1)] = test1[::-1] for c_perimeter in sortedpoints: segments.append(True) line_x, line_y = line(point[0], point[1], c_perimeter[0], c_perimeter[1]) for line_points in zip(line_x,line_y)[1:]: # if original_image[line_points[0]][line_points[1]] != 0: if self.FOOTPRINT_cleaned_opening[line_points[0]][line_points[1]] != 0: segments[-1] = False break min_boundpoints = (MINIMUM_BOUNDARY / 360.0) * len_cpoints seg_sizes = [] new_segment = True for segment in segments: if segment: if new_segment: seg_sizes.append(1) new_segment = False else: seg_sizes[-1] += 1 else: new_segment = True if segments[0] == True and segments[-1] == True and len(seg_sizes) > 1: seg_sizes[0] = seg_sizes[0] + seg_sizes[-1] seg_sizes.pop() if(len(seg_sizes) == 0 or max(seg_sizes) < min_boundpoints): # boundary_image[point[0]][point[1]] = 0 #TAMA BANG TANGGALIN? if (point[0],point[1]) in self.POINTS_ordered: ## IDENTIFY KUNG BAKIT NAGKA-ERRROR, EXAMPLE pt000120_merged4.py obj 1301 self.POINTS_ordered.remove((point[0],point[1]))
def find_iris(image, pupil, **kwargs): buffer = 20 # run canny image = filter.canny(image, sigma=1, low_threshold=10, high_threshold=50) cx, cy, radius = pupil segments = get_segments(400, step=0.01) # get ray directions directions = zip(map(cos, segments[0]), map(sin, segments[0])) shape = image.shape points = [] for d in directions: start = (cx + (radius + buffer) * d[0], cy + (radius + buffer)*d[1]) ray = Ray(image, start, d) point = ray.fire() if point != None: points.append(point) for p in points: x, y = circle_perimeter(int(p[0]), int(p[1]), 3) x = x[x < rgb.shape[0]] y = y[y < rgb.shape[1]] rgb[x,y] = (220, 40, 40) e = Ellipse().fit_with_center(None, points) return image, points, e
def form_mask_BR_v2(start_temp, max_temp, temp_rate): dtype = [('temp', float), ('mask', np.ndarray), ('dist', np.ndarray)] masks = [] #IMPROVEMENT!!! #MINUS LAST COORDINATES TO NEXT TEMPERATURE #LESS POINTS TO CHECK while (start_temp <= max_temp): coordinates = [] coor_dist = [] distance = int(round(start_temp)) array_size = distance * 2 + 1 img = np.zeros((array_size, array_size), dtype=np.uint8) rr, cc = circle_perimeter(distance, distance, distance) img[rr, cc] = 1 rr,cc = np.nonzero(ndimage.binary_fill_holes(img).astype(int)) img[rr, cc] = 1 for idx in xrange(0, len(rr)): dist_temp = np.linalg.norm(np.array([rr[idx], cc[idx]]) - np.array([distance, distance])) if dist_temp <= start_temp: coordinates.append([rr[idx], cc[idx]]) coor_dist.append(dist_temp) # coordinates.remove([distance, distance]) coordinates = coordinates - np.array([distance, distance]) masks.append((start_temp, coordinates, np.array(coor_dist))) start_temp += temp_rate return np.array(masks, dtype=dtype)
def add_auto_masks_area(areaFile,addMasks=False): from skimage.morphology import binary_dilation, binary_erosion, disk from skimage import exposure from skimage.transform import hough_circle from skimage.morphology import convex_hull_image from skimage.feature import canny from skimage.draw import circle_perimeter import h5py MASKs = np.zeros(areaFile.attrs['ROI_patches'].shape) if 'ROI_masks' in (areaFile.attrs.iterkeys()): print 'Masks have already been created' awns = raw_input('Would you like to redo them from scratch: (answer y/n): ') else: awns = 'y' if awns=='y': MASKs = np.zeros(areaFile.attrs['ROI_patches'].shape) for i in range(areaFile.attrs['ROI_patches'].shape[2]): patch = areaFile.attrs['ROI_patches'][:,:,i] tt0 = exposure.equalize_hist(patch) tt = 255*tt0/np.max(tt0) thresh = 1*tt>0.3*255 thresh2 = 1*tt<0.1*255 tt[thresh] = 255 tt[thresh2] = 0 edges = canny(tt, sigma=2, low_threshold=20, high_threshold=30) try_radii = np.arange(3,5) res = hough_circle(edges, try_radii) ridx, r, c = np.unravel_index(np.argmax(res), res.shape) r, c, try_radii[ridx] image = np.zeros([20,20,4]) cx, cy = circle_perimeter(c, r, try_radii[ridx]+2) try: image[cy, cx] = (220, 80, 20, 1) original_image = np.copy(image[:,:,3]) chull = convex_hull_image(original_image) image[chull,:] = (255, 0, 0, .4) except: pass MASKs[:,:,i] = (1*image[:,:,-1]>0) if addMasks: areaFile.attrs['ROI_masks'] = MASKs else: pass return np.array(MASKs)
def get_edges(np_image): # Get the coordinates of the circle edges X = [] Y = [] Z = [] circles = [] # to get the outlines of the circles C = [] # to get the centres of the circles, in relation to the different areas R = [] # to get radii coords = np.column_stack(np.nonzero(np_image)) X = np.array(coords[:, 0]) Y = np.array(coords[:, 1]) # Fit a circle and compare measured circle area with # area from the amount of pixels to remove trash XC, YC, RAD, RESID = leastsq_circle(X, Y) # Hough radius estimate hough_radii = np.arange(RAD - RAD / 2., RAD + RAD / 2.) # Apply Hough transform hough_res = hough_circle(np_image, hough_radii) centers = [] accums = [] radii = [] img = np.zeros_like(np_image) # For each radius, extract one circle for radius, h in zip(hough_radii, hough_res): peaks = peak_local_max(h, num_peaks=2) centers.extend(peaks) accums.extend(h[peaks[:, 0], peaks[:, 1]]) radii.extend([radius, radius]) for idx in np.argsort(accums)[::-1][:1]: center_x, center_y = centers[idx] C.append((center_x, center_y)) radius = radii[idx] R.append(radius) cx, cy = circle_perimeter(int(round(center_x, 0)), int(round(center_y, 0)), int(round(radius, 0))) circles.append((cx, cy)) if C: for cent in C: xc, yc = cent np_image[int(xc), int(yc)] = 255 np_image[int(xc)-5:int(xc)+5, int(yc)-5:int(yc)+5] = 255 if circles: for per in circles: e1, e2 = per np_image[e1, e2] = 255 return [C, R, circles, []], np_image
def get_perimeter(img): """ :param img: :return: """ cx = img.shape[0]/2 cc, rr = circle_perimeter(cx - 1, cx - 1, 256) return rr, cc
def __tutorial_hough_circle_detection_skiimage(img_path, min_dim=40, max_dim=60): """ This algorithm is crap, the one using opencv is much much better :param img_path: :param min_dim: :param max_dim: :return: """ # load picture and detect edges img = cv2.imread(img_path) img = cv2.cvtColor(img, cv2.COLOR_BGRA2GRAY) img_edges = canny(img, sigma=3, low_threshold=10, high_threshold=50) centers = [] accums = [] radii = [] # detect all radii within the range min_radius = int(min_dim / 2) max_radius = int(max_dim / 2) hough_radii = np.arange(start=min_radius, stop=max_radius, step=1) hough_res = hough_circle(img_edges, hough_radii) for radius, h in zip(hough_radii, hough_res): # for each radius, extract 2 circles num_peaks = 2 peaks = peak_local_max(h, num_peaks=num_peaks) centers.extend(peaks) accums.extend(h[peaks[:, 0], peaks[:, 1]]) radii.extend([radius] * num_peaks) img_width = img.shape[1] img_height = img.shape[0] # get the sorted accumulated values # accums_sorted = np.asarray(accums) # accums_sorted = accums_sorted[idx_sorted] # don't consider circles with accum value less than the threshold accum_threshold = 0.3 idx_sorted = np.argsort(accums)[::-1] # draw the most prominent n circles, i.e those # with the highest n peaks img_color = color.gray2rgb(img) for idx in idx_sorted: if accums[idx] < accum_threshold: continue center_y, center_x = centers[idx] radius = radii[idx] cx, cy = circle_perimeter(center_x, center_y, radius) cx[cx > img_width - 1] = img_width - 1 cy[cy > img_height - 1] = img_height - 1 img_color[cy, cx] = (220, 20, 20) # save the result skimage.io.imsave("D://_Dataset//GTSDB//Test_Regions//_img2_.png", img_color)
def auto_find_center_rings(avg_img, sigma=1, no_rings=4, min_samples=3, residual_threshold=1, max_trials=1000): """This will find the center of the speckle pattern and the radii of the most intense rings. Parameters ---------- avg_img : 2D array shape of the image sigma : float, optional Standard deviation of the Gaussian filter. no_rings : int, optional number of rings min_sample : int, optional The minimum number of data points to fit a model to. residual_threshold : float, optional Maximum distance for a data point to be classified as an inlier. max_trials : int, optional Maximum number of iterations for random sample selection. Returns ------- center : tuple center co-ordinates of the speckle pattern image : 2D array Indices of pixels that belong to the rings, directly index into an array radii : list values of the radii of the rings Note ---- scikit-image ransac method(http://www.imagexd.org/tutorial/lessons/1_ransac.html) is used to automatically find the center and the most intense rings. """ image = img_as_float(color.rgb2gray(avg_img)) edges = feature.canny(image, sigma) coords = np.column_stack(np.nonzero(edges)) edge_pts_xy = coords[:, ::-1] radii = [] for i in range(no_rings): model_robust, inliers = ransac(edge_pts_xy, CircleModel, min_samples, residual_threshold, max_trials=max_trials) if i == 0: center = int(model_robust.params[0]), int(model_robust.params[1]) radii.append(model_robust.params[2]) rr, cc = draw.circle_perimeter(center[1], center[0], int(model_robust.params[2]), shape=image.shape) image[rr, cc] = i + 1 edge_pts_xy = edge_pts_xy[~inliers] return center, image, radii
def count_dishes(out, sink): edges = canny( sink, sigma=2, #low_threshold=10, high_threshold=0.3 ) hough_radii = np.arange(25, 70, 1) hough_res = hough_circle(edges, hough_radii) centers = [] accums = [] radii = [] for radius, h in zip(hough_radii, hough_res): num_peaks = 2 peaks = peak_local_max(h, num_peaks=num_peaks) centers.extend(peaks) accums.extend(h[peaks[:, 0], peaks[:, 1]]) radii.extend([radius] * num_peaks) sink = color.gray2rgb(sink) hits = {} for idx in np.argsort(accums)[::-1][:25]: center_x, center_y = centers[idx] radius = radii[idx] if is_sink_hole(center_x, center_y, radius): continue for d in hits.keys(): dx, dy, dr = d dt = distance(center_x, dx, center_y, dy) if dt <= 40 and abs(dr - radius) < 50: hits[d] += 1 break else: hits[(center_x, center_y, radius)] = 1 dishes = [k for k,v in hits.iteritems()] for dish in dishes: center_x, center_y, radius = dish cx, cy = circle_perimeter(center_y, center_x, radius) try: sink[cy, cx] = (220, 250, 20) except IndexError: continue draw_res(out, sink, edges) return len(dishes)
def test_hough_circle_peaks_total_peak(): img = np.zeros((120, 100), dtype=int) x_0, y_0, rad_0 = (99, 50, 20) y, x = circle_perimeter(y_0, x_0, rad_0) img[x, y] = 1 x_1, y_1, rad_1 = (49, 60, 30) y, x = circle_perimeter(y_1, x_1, rad_1) img[x, y] = 1 radii = [rad_0, rad_1] hspaces = tf.hough_circle(img, radii) out = tf.hough_circle_peaks(hspaces, radii, min_xdistance=1, min_ydistance=1, threshold=None, num_peaks=np.inf, total_num_peaks=1) assert_equal(out[1][0], np.array([y_1,])) assert_equal(out[2][0], np.array([x_1,])) assert_equal(out[3][0], np.array([rad_1,]))
def mask_transform(f, y0, x0, r, dr): import skimage.draw as draw _f0 = np.zeros(f.shape) _f1 = np.zeros(f.shape) for _ir in range(r-dr, r+dr+1): yy, xx = draw.circle_perimeter(y0, x0, _ir, 'andres') _f0[yy, xx] = 1 _f1[np.where(np.logical_and(f, _f0))] = 1 _v, _fv = fuzzyHT(_f1, range(10, 50)) return _f1, _fv
def detect(path,**kwargs): d = Dataset('./data') image = d.read(path) global rgb rgb = d.read(path) pupil = find_pupil(image, 15)[0] e = Ellipse() e._axes = (pupil[2], pupil[2]) e._center = pupil[0:2] x, y = circle_perimeter(pupil[0], pupil[1], pupil[2]) #rgb[x,y] = 255 return e, image
def get_circle_perimeter(size, y, x, r): #zwraca czarny obraz z wyrysowanym okregiem o zadanych parametrach max_y, max_x = size w = np.zeros(size) rr, cc = circle_perimeter(y, x, r) trr = np.array([0]) tcc = np.array([0]) for i, r in enumerate(rr): if r >= 0 and r < max_y: if cc[i] >= 0 and cc[i] < max_x: trr = np.concatenate((trr, [r])) tcc = np.concatenate((tcc, [cc[i]])) w[trr, tcc] = 1 return w
def test_hough_circle(): # Prepare picture img = np.zeros((120, 100), dtype=int) radius = 20 x_0, y_0 = (99, 50) y, x = circle_perimeter(y_0, x_0, radius) img[x, y] = 1 out = tf.hough_circle(img, np.array([radius], dtype=np.intp)) x, y = np.where(out[0] == out[0].max()) assert_equal(x[0], x_0) assert_equal(y[0], y_0)
def _helper_find_rings(proc_method, center, radii_list): x, y = center image_size = (256, 265) numpy.random.seed(42) noise = np.random.rand(*image_size) tt = np.zeros(image_size) for r in radii_list: rr, cc = skd.circle_perimeter(x, y, r) tt[rr, cc] = 1 tt = binary_dilation(tt, structure=np.ones((3, 3))).astype(float) * 100 tt = tt + noise res = proc_method(tt) assert_equal(res, center)
def detect(d, i,**kwargs): image = d.read(d.images[i]) global rgb rgb = d.read(d.images[i], flatten=False) pupil = find_pupil(image)[0] img, points, ellipse = find_iris(image, pupil, **kwargs) x, y = circle_perimeter(pupil[0], pupil[1], pupil[2]) rgb[x,y] = (220, 40, 40) ex, ey = ellipse.center major, minor = ellipse.axes orientation = ellipse.orientation x, y = ellipse_perimeter(int(ex), int(ey), int(major), int(minor), orientation) rgb[x,y] = (220, 40, 40) imshow(rgb)
def extract_hough_circle(img_rgb, img_gray, out_filepath): # Canny img = img_as_ubyte(img_gray) edges = canny(img, sigma=3, low_threshold=10, high_threshold=50) # fig, ax = plt.subplots(nrows=1, ncols=1) # ax.imshow(edges, cmap=plt.cm.gray) # ax.axis('off') # ax.set_title('Canny Edges for Hough Circle', fontsize=18) # plt.tight_layout() # plt.savefig('canny_edges_for_hough_circle.png') # Detect min_radii = 15; max_radii = 30; step_radii = 1 plausible_radii = np.arange(min_radii, max_radii, step_radii) hough_circles = hough_circle(edges, plausible_radii) centers = []; accums = []; radii = [] for radius, h in zip(plausible_radii, hough_circles): n_extracted_circle = 1 # ...for each radius peaks = peak_local_max(h, num_peaks=n_extracted_circle) centers.extend(peaks) accums.extend(h[peaks[:, 0], peaks[:, 1]]) radii.extend([radius] * n_extracted_circle) # Draw the most prominent circles n_top_circle = 15 fig, ax = plt.subplots(ncols=1, nrows=1) for idx in np.argsort(accums)[::-1][:n_top_circle]: center_x, center_y = centers[idx] center_color = (0, 225, 0) img_rgb[center_x, center_y] = center_color radius = radii[idx] perim_color = (255, 0, 0) perim_x_list, perim_y_list = circle_perimeter(center_y, center_x, radius) # if all(i < img_rgb.shape[1] for i in perim_x_list) and all(i < img_rgb.shape[0] for i in perim_y_list): # img_rgb[perim_y_list, perim_x_list] = perim_color for perim_x, perim_y in zip(perim_x_list, perim_y_list): if perim_x < img_rgb.shape[1] and perim_y < img_rgb.shape[0]: img_rgb[perim_y, perim_x] = perim_color ax.imshow(img_rgb, cmap=plt.cm.gray) ax.axis('off') ax.set_title('Hough Circle', fontsize=18) plt.tight_layout() plt.savefig(out_filepath) plt.close(fig)
def test_hessian_matrix_eigvals_3d(im3d, dtype): im3d = im3d.astype(dtype, copy=False) H = hessian_matrix(im3d) E = hessian_matrix_eigvals(H) out_dtype = _supported_float_type(dtype) assert all(a.dtype == out_dtype for a in E) # test descending order: e0, e1, e2 = E assert np.all(e0 >= e1) and np.all(e1 >= e2) E0, E1, E2 = E[:, E.shape[1] // 2] # cross section row_center, col_center = np.array(E0.shape) // 2 circles = [ draw.circle_perimeter(row_center, col_center, radius, shape=E0.shape) for radius in range(1, E0.shape[1] // 2 - 1) ] response0 = np.array([np.mean(E0[c]) for c in circles]) response2 = np.array([np.mean(E2[c]) for c in circles]) # eigenvalues are negative just inside the sphere, positive just outside assert np.argmin(response2) < np.argmax(response0) assert np.min(response2) < 0 assert np.max(response0) > 0
def test_circle_detect(): from guang.cv.video import getFrame import matplotlib.pyplot as plt from skimage.draw import circle_perimeter from skimage import color # dst = cv2.pyrMeanShiftFiltering(image, 10, 100) #边缘保留滤波EPF fps, size_17, img = getFrame( filename=r'C:\Users\beidongjiedeguang\Desktop\实验\62.avi', frameNum=723, ) image = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) accums, cx, cy, radii = circle_detect(image, rangeR=[100, 250], total_num_peaks=1) image = color.gray2rgb(image) for center_y, center_x, radius in zip(cy, cx, radii): circy, circx = circle_perimeter(center_y, center_x, radius) image[circy, circx] = (220, 20, 20) fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(20, 10)) ax.imshow(image, cmap=plt.cm.gray) plt.show()
def test_hough_circle_peaks_total_peak_and_min_distance(): img = np.zeros((120, 120), dtype=int) cx = cy = [40, 50, 60, 70, 80] radii = range(20, 30, 2) for i in range(len(cx)): y, x = circle_perimeter(cy[i], cx[i], radii[i]) img[x, y] = 1 hspaces = transform.hough_circle(img, radii) out = transform.hough_circle_peaks(hspaces, radii, min_xdistance=15, min_ydistance=15, threshold=None, num_peaks=np.inf, total_num_peaks=2, normalize=True) # 2nd (4th) circle is removed as it is close to 1st (3rd) oneself. # 5th is removed as total_num_peaks = 2 assert_equal(out[1], np.array(cy[:4:2])) assert_equal(out[2], np.array(cx[:4:2])) assert_equal(out[3], np.array(radii[:4:2]))
def do(frame): # rf = cv2.cvtColor(rf, cv2.COLOR_BGR2GRAY) lex, rex, ley, hey = calc_bounds(frame) rr, cc = draw.circle_perimeter(lex + 150, ley + 150, 150) frame[rr, cc, 0] = (255, 0, 0) # frame = frame[ley:hey, lex:rex, :] for_net = cv2.resize(frame, (150, 150)) for_net = np.swapaxes(for_net, 0, 2) for_net = for_net.reshape( (1, 3, 150, 150) + for_net.shape) # this is a Numpy array with shape (1, 3, 150, 150) res = model.predict(for_net) print(res) pass # res = net1.predict(rf.reshape(1,9216) / 255)[0] # res = net1.predict(rf.reshape(1,1,96,96) / 255)[0] # for x,y in zip(res[0::2]*48+48, res[1::2]*48+48): # cv2.drawMarker(rf, (int(x), int(y)), 255) return frame
def mid_phantom(image_ACR, imarray): # Detect edges in image edges = filters.canny(imarray, sigma=3, low_threshold=200, high_threshold=1000) hough_radii = np.array([190/2/image_ACR.PixelSpacing[1]]) print type(edges) print type(hough_radii) hough_res = hough_circle(edges, hough_radii) # Detect contours and middle of phantom centers = [] radii = [] for radius, h in zip(hough_radii, hough_res): peaks = peak_local_max(h, num_peaks=1) centers.extend(peaks) radii.extend([radius, radius]) center_x, center_y = centers[0] radius = radii[1] # Niet nodig? radius = np.int32(radius) # Niet nodig? cy, cx = circle_perimeter(center_y, center_x, radius) # Niet nodig? return center_x, center_y, radii
def main(): img = os.path.join(os.getcwd(), 'newstage1.jpg') image = imread(img, as_gray=True) image = img_as_ubyte(image) image = ndi.gaussian_filter(image, 1) edges1 = canny(image, sigma=1, low_threshold=10, high_threshold=50) hough_radii = np.arange(20, 60, 3) hough_res = hough_circle(edges1, hough_radii) accums, cx, cy, radii = hough_circle_peaks(hough_res, hough_radii, total_num_peaks=3) print(len(radii)) image = color.gray2rgb(image) for center_y, center_x, radius in zip(cy, cx, radii): circy, circx = circle_perimeter(center_y, center_x, radius, shape=image.shape) image[circy, circx] = (220, 20, 20) fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(10, 4), sharex=True, sharey=True) ax1.imshow(image, cmap=plt.cm.gray) ax2.imshow(edges1, cmap=plt.cm.gray) plt.show()
def hough_circles(edge_map, radius_range): # you can compare you solution, to a reference implementation: #acc = hough_circle(edge_map, radius_range) # <- remove this angles = np.arange(0, (2. - 2. / 360) * np.pi, 1. / 360) print(edge_map.shape) acc = np.zeros((radius_range.shape[0], edge_map.shape[0], edge_map.shape[1])).astype(np.float32) for i, radius in enumerate(radius_range): print(i) with np.nditer(edge_map, flags=['multi_index']) as it: for px in it: if px > 0: rr, cc = draw.circle_perimeter(it.multi_index[1], it.multi_index[0], radius) rr_FilterIndex = np.where((rr >= edge_map.shape[1]) | (rr < 0)) cc_FilterIndex = np.where((cc >= edge_map.shape[0]) | (cc < 0)) val_FilterIndex = np.append(rr_FilterIndex, cc_FilterIndex) rr = np.delete(rr, val_FilterIndex) cc = np.delete(cc, val_FilterIndex) #print(rr, cc) acc[i, cc, rr] += 1 #skimage.draw #acc[i] += (radius * np.cos(angles) + it.multi_index[0], radius * np.sin(angles) + it.multi_index[1]) print(acc[i]) acc /= acc.max() # TODO: remove above line and implement your own Hough Transformation: # acc = ... return acc
def circle(image): edges = canny(image, sigma=3, low_threshold=10, high_threshold=50) # Detect two radii hough_radii = np.arange(20, 35, 2) hough_res = hough_circle(edges, hough_radii) # Select the most prominent 3 circles accums, cx, cy, radii = hough_circle_peaks(hough_res, hough_radii, total_num_peaks=3) # Draw them fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(10, 4)) image = color.gray2rgb(image) for center_y, center_x, radius in zip(cy, cx, radii): circy, circx = circle_perimeter(center_y, center_x, radius, shape=image.shape) image[circy, circx] = (220, 20, 20) ax.imshow(image, cmap=plt.cm.gray) plt.show()
def create_circle_center(img_shape, centers, radius=10): """ create initialisation from centres as small circles :param img_shape: :param [[int, int]] centers: :param int radius: :return: """ mask_circle = np.zeros(img_shape, dtype=int) mask_perimeter = np.zeros(img_shape, dtype=int) center_circles = list() for i, pos in enumerate(centers): rr, cc = draw.circle(int(pos[0]), int(pos[1]), radius, shape=img_shape[:2]) mask_circle[rr, cc] = i + 1 rr, cc = draw.circle_perimeter(int(pos[0]), int(pos[1]), radius, shape=img_shape[:2]) mask_perimeter[rr, cc] = i + 1 center_circles.append(np.array([rr, cc]).transpose()) return center_circles, mask_circle, mask_perimeter
def getCellsInPlane(shape, points, order, prefix, index, plsmns): cellsImg = np.zeros(shape, dtype=np.uint16) blobs = [] col = order[0] for i in range(len(points[:, col])): point = int(np.round(points[i, col])) if index - plsmns <= point <= index + plsmns: blobs.append([points[i, :]]) blobs = np.concatenate(blobs) print(len(blobs)) for i in range(len(blobs)): y = int(np.round(blobs[i, order[1]])) x = int(np.round(blobs[i, order[2]])) r, c, rad = y, x, 1 rr, cc = circle_perimeter(r, c, rad) try: cellsImg[rr, cc] = 65535 except IndexError: print('point {}, {}, out of range'.format(y, x)) saveName = prefix + '_' + str(col) + '_' + str(index) + '.tif' with TiffWriter(saveName) as tif: tif.save(cellsImg) return cellsImg
def find_iris(image, pupil, **kwargs): buffer = 20 # run canny image = filter.canny(image, sigma=1, low_threshold=10, high_threshold=50) cx, cy, radius = pupil segments = get_segments(17, step=0.05) # get ray directions directions = zip(map(cos, segments[0]), map(sin, segments[0])) shape = image.shape points = [] for d in directions: start = (cx + (radius + buffer) * d[0], cy + (radius + buffer) * d[1]) ray = Ray(image, start, d) point = ray.fire() if point != None: points.append(point) for p in points: x, y = circle_perimeter(int(p[0]), int(p[1]), 3) rgb[x, y] = (220, 40, 40) e = Ellipse().fit_with_center(None, points) return image, points, e
def remove_optic_disk(image): roi = getROI(image) preprocessed_roi = preprocess(roi) # im2, contours, hierarchy = cv2.findContours(segmented, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) ##We get our ROI and then we preprocess it. ##After preprocess, we apply a canny border algorithm ##We dilate the borders in order to make it easy to detect with hough edged = canny(preprocessed_roi, 0.22) kernel = np.ones((3, 3), np.uint8) edged = cv2.dilate(edged, kernel, iterations=3) accums, cx, cy, radii = hough(edged, 55, 80) for center_y, center_x, radius in zip(cy, cx, radii): circy, circx = circle_perimeter(center_y, center_x, radius) try: roi[circy, circx] = (220, 20, 20) except: continue # init = np.array([circx, circy]).T return preprocessed_roi, roi
def extraCredit(): egg_img = np.array(imread('./egg.jpg')) jupiter_img = np.array(imread('./jupiter.jpg')) draw_color = np.array([255, 255, 0]) radius = [2, 12] sigma = 2 threshold = 0.65 use_gradient = False bin_scale = 1 epsilon = 0.05 centers, hough_space = detect_circles(egg_img, radius, use_Grad=use_gradient, threshold=threshold, sigma=sigma, bin_scale=bin_scale, epsilon=epsilon, hough=True) hough_img = hough_space.astype(int).sum(axis=0) scale_factor = 255 / hough_img.max() hough_img = (scale_factor * hough_img).astype(np.uint8) circled_img = egg_img.copy() for center in centers: circle = circle_perimeter(center[1], center[2], radius=center[0], shape=img.shape) circled_img[circle] = draw_color plt.rcParams['figure.figsize'] = [16, 10] fig, axs = plt.subplots(1, 2) axs[0].imshow(circled_img) axs[1].imshow(hough_img, cmap='gray') axs[0].title.set_text('Circles Marked') axs[1].title.set_text('Accumulator Array') plt.show() hough_img = hough_space hough_img_threshold = hough_img.copy() hough_img_threshold[hough_img < hough_img.max() * threshold] = 0 hough_img_threshold[hough_img_threshold > 0] = 1 hough_img_threshold = hough_img_threshold.astype(bool) labels = measure.label(hough_img_threshold, background=0) count = labels.max() centers = [] for i in range(1, count + 1): centers.append((np.mean(np.array(np.where(labels == i)), axis=1) / bin_scale).astype(int)) centers = np.array(centers) circled_img = egg_img.copy() for center in centers: circle = circle_perimeter(center[1], center[2], radius=center[0] + radius[0], shape=img.shape) circled_img[circle] = draw_color print('Circle Count:', count)
def detect_circles(img, radius, use_Grad=False, sigma=1.0, threshold=0.8, epsilon='auto', bin_scale=1, hough=False): # Detect edges img_gray = img_as_float(rgb2gray(img)) edges = canny(img_gray, sigma=sigma) #For examples using gradient if use_Grad: g_x = convolve(img_gray, np.array([[1, -1]]), mode='wrap') g_y = convolve(img_gray, np.array([[1], [-1]]), mode="wrap") g_x[g_x == 0] = 1e-10 g_direct = np.arctan(g_y / g_x) # Detect circles flag = False if type(radius) is not list: flag = True radius = [radius, radius + 1] temp_0 = radius[1] - radius[0] temp_1 = int(img.shape[0] * bin_scale) temp_2 = int(img.shape[1] * bin_scale) votes = np.zeros((temp_0, temp_1, temp_2)) for rad in range(radius[0], radius[1]): hough_space = np.zeros((temp_1, temp_2)) for row in range(img.shape[0]): for col in range(img.shape[1]): if edges[row, col] != 0: if not use_Grad and epsilon == 'auto': v = np.linspace(0, 2 * np.pi, 6 * rad) elif not use_Grad and epsilon != 'auto': v = np.arange(0, 2 * np.pi, epsilon) if use_Grad: theta = g_direct[row, col] v = np.array([theta, theta - np.pi]) for theta in v: vote_x = int( round(col + rad * np.cos(theta)) * bin_scale) vote_y = int( round(row + rad * np.sin(theta)) * bin_scale) if vote_x >= 0 and vote_x < hough_space.shape[ 1] and vote_y >= 0 and vote_y < hough_space.shape[ 0]: hough_space[vote_y, vote_x] = hough_space[vote_y, vote_x] + 1 votes[rad - radius[0]] = hough_space if flag: hough_space = votes[0] centers = (np.transpose( np.array(np.where(hough_space >= hough_space.max() * threshold))) / bin_scale).astype(int) if not hough: return centers return centers, hough_space else: centroid = (np.transpose( np.array(np.where(votes >= votes.max() * threshold))) / bin_scale).astype(int) centroid[:, 0] = centroid[:, 0] + radius[0] if not hough: return centroid return centroid, votes circled_img = img.copy() for center in centers: circle = circle_perimeter(center[0], center[1], radius=radius, shape=img.shape) circled_img[circle] = draw_color imsave('reduced_' + save_name_circled, circled_img) print('Circle Count:', count)
epsilon = 0.1 circled_img = img.copy() centers, votes = detect_circles(img, radius, use_Grad=use_Grad, threshold=threshold, sigma=sigma, bin_scale=bin_scale, epsilon=epsilon, hough=True) scale_factor = 255 / votes.max() hough_img = (scale_factor * votes).astype(np.uint8) labels = measure.label(hough_img_threshold, background=0) count = labels.max() for center in centers: circle = circle_perimeter(center[0], center[1], radius=radius, shape=img.shape) circled_img[circle] = draw_color plt.rcParams['figure.figsize'] = [16, 10] fig, axs = plt.subplots(1, 2) print(count) axs[0].imshow(circled_img) axs[1].imshow(hough_img, cmap='gray') axs[0].title.set_text('Circles Marked') axs[1].title.set_text('Accumulator Array') plt.show() # For grader, feel free to uncomment and run extraCredit, # I put the parameters for egg.jpg only, you could change filename # extraCredit()
def draw_circle_perimeter(frame, center_x, center_y, radius, color): cy, cx = circle_perimeter(int(center_y), int(center_x), int(radius)) cy, cx = _coords_inside_image(cy, cx, frame.shape) frame[cy, cx] = color
def test_img_plot( img_name, img_read_loc, img_read_format='.tif', img_save_loc=None, img_save_format='png', tly=123, bly=415, bry=427, trry=136, part_cx=False, part_cy=False, draw_bpe_color=None, draw_particle_color=None, draw_particle=True, draw_bpe=True, show=True, save=False, pause_time=3, um_per_pix=1, bf=35, draw_particle_radius=10, ): # other variables lr_shift_y = 14 # angle of image w = 550 # channel width # read file path img_name = img_name + '_X1' image_read = img_read_loc + img_name + img_read_format # load image img = io.imread(image_read) # calculate image shape img_dims = np.shape(img) # calculate BPE locations centerline = int( np.round((np.mean([tly, bly]) + np.mean([bry, trry])) / 2, 0)) bpe_leadedge_centerline = int(np.round((np.mean([tly, bly])))) # draw bpe rectangle if draw_bpe == True: # choose color if draw_bpe_color == None: draw_bpe_color = int(np.round(bf * np.mean(img), 0)) # organize particle data xloc = int(np.round((part_cx) / um_per_pix, 0)) yloc = int(np.round((part_cy) / um_per_pix, 0)) # draw rectangle poly = np.array( ((yloc - thresh, xloc - thresh), (yloc - thresh, xloc + thresh), (yloc + thresh, xloc + thresh), (yloc + thresh, xloc - thresh), (yloc - thresh, xloc - thresh))) rr, cc = polygon_perimeter(poly[:, 0], poly[:, 1], img.shape) img[rr, cc] = draw_bpe_color # rescale back to micron coordinates and adjust image name xloc = int(np.round(xloc * um_per_pix, 0)) yloc = int(np.round(yloc * um_per_pix, 0)) # draw centerline line #rr, cc = line(centerline, 0, centerline, 511) #img[rr, cc] = draw_bpe_color # draw wall lines rr, cc = line( int(np.round(centerline + (w / um_per_pix) / 2, 0) - 6), 0, int( np.round(centerline + (w / um_per_pix) / 2 + lr_shift_y, 0) - 6), 511) img[rr, cc] = draw_bpe_color rr, cc = line( int(np.round(centerline - (w / um_per_pix) / 2, 0) - 6), 0, int( np.round(centerline - (w / um_per_pix) / 2 + lr_shift_y, 0) - 6), 511) img[rr, cc] = draw_bpe_color # draw particle if draw_particle == True: # choose color if draw_particle_color == None: draw_particle_color = int(np.round(np.min(img), 0)) # organize particle data xloc = int(np.round((part_cx) / um_per_pix, 0)) yloc = int(np.round((part_cy) / um_per_pix, 0)) # create circle perimeter rr, cc = circle_perimeter(yloc, xloc, draw_particle_radius) rr = np.where(rr > 511, 511, rr) rr = np.where(rr < 0, 0, rr) cc = np.where(cc > 511, 511, cc) cc = np.where(cc < 0, 0, cc) img[rr, cc] = draw_particle_color # rescale back to micron coordinates xloc = int(np.round(xloc * um_per_pix, 0)) yloc = int(np.round(yloc * um_per_pix, 0)) # adjust image name img_name = "Image-Particle_X" + str(xloc) + '.Y' + str(yloc) # create figure fig, ax = plt.subplots(figsize=(8, 8)) ax.imshow(img * bf, cmap='gray', extent=(0, img_dims[0] * um_per_pix, img_dims[1] * um_per_pix, 0)) ax.set_title(img_name) plt.xlabel('Axial - Channel (um)') plt.ylabel('Transverse - Channel (um)') plt.grid(color='dimgray', alpha=0.25, linestyle='-', linewidth=0.25) # display if show == True: plt.show() plt.pause(pause_time) # save if save == True: image_save = img_save_loc + img_name + '.' + img_save_format #plt.imsave(image_save, img * bf, format=img_save_format, cmap='gray') #plt_img_save = img_save_loc + img_name + '_plt.' + img_save_format print(image_save) plt.savefig(image_save, format=img_save_format) plt.close(fig=None) # return centerline return centerline
def png_set_color(img, x, y, d): """Draw the nodule marker box.""" img_rgb = np.array(Image.fromarray(img).convert("RGB")) rr, cc = draw.circle_perimeter(y, x, d // 2 + 4) draw.set_color(img_rgb, [rr, cc], [0, 0, 255], alpha=1.0)
edges = canny(image, sigma=3, low_threshold=10, high_threshold=50) # Detect two radii hough_radii = np.arange(20, 35, 2) hough_res = hough_circle(edges, hough_radii) # Select the most prominent 5 circles accums, cx, cy, radii = hough_circle_peaks(hough_res, hough_radii, total_num_peaks=3) # Draw them fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(10, 4)) image = color.gray2rgb(image) for center_y, center_x, radius in zip(cy, cx, radii): circy, circx = circle_perimeter(center_y, center_x, radius) image[circy, circx] = (220, 20, 20) ax.imshow(image, cmap=plt.cm.gray) plt.show() ###################################################################### # Ellipse detection # ================= # # In this second example, the aim is to detect the edge of a coffee cup. # Basically, this is a projection of a circle, i.e. an ellipse. The problem # to solve is much more difficult because five parameters have to be # determined, instead of three for circles. # # Algorithm overview
def detect_circles(np_image): """ Uses Hough transform to detect the radii and the centres of the "blobs" indicating the point of contact between the spheres """ import numpy as np import pylab as pl from skimage.transform import hough_circle from skimage.feature import peak_local_max from skimage.draw import circle_perimeter pl.close('all') min_rad = int(max(np_image.shape[0], np_image.shape[1]) / 4.0) max_rad = int(max(np_image.shape[0], np_image.shape[1]) / 2.0) step = 1 hough_radii = np.arange(min_rad, max_rad, step, np.float64) hough_res = hough_circle(np_image, hough_radii) centers = [] accums = [] radii = [] circles = [] # to get the outlines of the circles C = [ ] # to get the centres of the circles, in relation to the different areas # For each radius, extract one circle for radius, h in zip(hough_radii, hough_res): peaks = peak_local_max(h, num_peaks=1) centers.extend(peaks) accums.extend(h[peaks[:, 0], peaks[:, 1]]) radii.extend([radius]) for idx in np.argsort(accums)[::-1][:1]: center_x, center_y = centers[idx] C.append((center_x, center_y)) radius = radii[idx] cx, cy = circle_perimeter(center_y, center_x, np.int64(radius)) circles.append((cy, cx)) #np_image[circles[0][0], circles[0][1]] = 0 # pl.imshow(np_image) # pl.title('Circle detection on real image using Hough transform\n- optimised with image labelling algorithm -', fontdict={'fontsize': 20,'verticalalignment': 'baseline','horizontalalignment': 'center'}) # pl.colorbar() # pl.show() # C_cp = C # C = [] # # if radius % 2 != 0: # C.append((C_cp[0][0] + 0.5, C_cp[0][1] + 0.5)) # elif radius % 2 != 0: # C.append((C_cp[0][0] + 0.5, C_cp[0][1])) # elif radius % 2 != 0: # C.append((C_cp[0][0], C_cp[0][1] + 0.5)) # else: # C.append((C_cp[0][0], C_cp[0][1])) return C
def daisy(img, step=4, radius=15, rings=3, histograms=8, orientations=8, normalization='l1', sigmas=None, ring_radii=None, visualize=False): '''Extract DAISY feature descriptors densely for the given image. DAISY is a feature descriptor similar to SIFT formulated in a way that allows for fast dense extraction. Typically, this is practical for bag-of-features image representations. The implementation follows Tola et al. [1]_ but deviate on the following points: * Histogram bin contribution are smoothed with a circular Gaussian window over the tonal range (the angular range). * The sigma values of the spatial Gaussian smoothing in this code do not match the sigma values in the original code by Tola et al. [2]_. In their code, spatial smoothing is applied to both the input image and the center histogram. However, this smoothing is not documented in [1]_ and, therefore, it is omitted. Parameters ---------- img : (M, N) array Input image (greyscale). step : int, optional Distance between descriptor sampling points. radius : int, optional Radius (in pixels) of the outermost ring. rings : int, optional Number of rings. histograms : int, optional Number of histograms sampled per ring. orientations : int, optional Number of orientations (bins) per histogram. normalization : [ 'l1' | 'l2' | 'daisy' | 'off' ], optional How to normalize the descriptors * 'l1': L1-normalization of each descriptor. * 'l2': L2-normalization of each descriptor. * 'daisy': L2-normalization of individual histograms. * 'off': Disable normalization. sigmas : 1D array of float, optional Standard deviation of spatial Gaussian smoothing for the center histogram and for each ring of histograms. The array of sigmas should be sorted from the center and out. I.e. the first sigma value defines the spatial smoothing of the center histogram and the last sigma value defines the spatial smoothing of the outermost ring. Specifying sigmas overrides the following parameter. ``rings = len(sigmas) - 1`` ring_radii : 1D array of int, optional Radius (in pixels) for each ring. Specifying ring_radii overrides the following two parameters. ``rings = len(ring_radii)`` ``radius = ring_radii[-1]`` If both sigmas and ring_radii are given, they must satisfy the following predicate since no radius is needed for the center histogram. ``len(ring_radii) == len(sigmas) + 1`` visualize : bool, optional Generate a visualization of the DAISY descriptors Returns ------- descs : array Grid of DAISY descriptors for the given image as an array dimensionality (P, Q, R) where ``P = ceil((M - radius*2) / step)`` ``Q = ceil((N - radius*2) / step)`` ``R = (rings * histograms + 1) * orientations`` descs_img : (M, N, 3) array (only if visualize==True) Visualization of the DAISY descriptors. References ---------- .. [1] Tola et al. "Daisy: An efficient dense descriptor applied to wide- baseline stereo." Pattern Analysis and Machine Intelligence, IEEE Transactions on 32.5 (2010): 815-830. .. [2] http://cvlab.epfl.ch/alumni/tola/daisy.html ''' # Validate image format. if img.ndim > 2: raise ValueError('Only grey-level images are supported.') if img.dtype.kind != 'f': img = img_as_float(img) # Validate parameters. if sigmas is not None and ring_radii is not None \ and len(sigmas) - 1 != len(ring_radii): raise ValueError('len(sigmas)-1 != len(ring_radii)') if ring_radii is not None: rings = len(ring_radii) radius = ring_radii[-1] if sigmas is not None: rings = len(sigmas) - 1 if sigmas is None: sigmas = [radius * (i + 1) / float(2 * rings) for i in range(rings)] if ring_radii is None: ring_radii = [radius * (i + 1) / float(rings) for i in range(rings)] if normalization not in ['l1', 'l2', 'daisy', 'off']: raise ValueError('Invalid normalization method.') # Compute image derivatives. dx = np.zeros(img.shape) dy = np.zeros(img.shape) dx[:, :-1] = np.diff(img, n=1, axis=1) dy[:-1, :] = np.diff(img, n=1, axis=0) # Compute gradient orientation and magnitude and their contribution # to the histograms. grad_mag = sqrt(dx ** 2 + dy ** 2) grad_ori = arctan2(dy, dx) orientation_kappa = orientations / pi orientation_angles = [2 * o * pi / orientations - pi for o in range(orientations)] hist = np.empty((orientations,) + img.shape, dtype=float) for i, o in enumerate(orientation_angles): # Weigh bin contribution by the circular normal distribution hist[i, :, :] = exp(orientation_kappa * cos(grad_ori - o)) # Weigh bin contribution by the gradient magnitude hist[i, :, :] = np.multiply(hist[i, :, :], grad_mag) # Smooth orientation histograms for the center and all rings. sigmas = [sigmas[0]] + sigmas hist_smooth = np.empty((rings + 1,) + hist.shape, dtype=float) for i in range(rings + 1): for j in range(orientations): hist_smooth[i, j, :, :] = gaussian_filter(hist[j, :, :], sigma=sigmas[i]) # Assemble descriptor grid. theta = [2 * pi * j / histograms for j in range(histograms)] desc_dims = (rings * histograms + 1) * orientations descs = np.empty((desc_dims, img.shape[0] - 2 * radius, img.shape[1] - 2 * radius)) descs[:orientations, :, :] = hist_smooth[0, :, radius:-radius, radius:-radius] idx = orientations for i in range(rings): for j in range(histograms): y_min = radius + int(round(ring_radii[i] * sin(theta[j]))) y_max = descs.shape[1] + y_min x_min = radius + int(round(ring_radii[i] * cos(theta[j]))) x_max = descs.shape[2] + x_min descs[idx:idx + orientations, :, :] = hist_smooth[i + 1, :, y_min:y_max, x_min:x_max] idx += orientations descs = descs[:, ::step, ::step] descs = descs.swapaxes(0, 1).swapaxes(1, 2) # Normalize descriptors. if normalization != 'off': descs += 1e-10 if normalization == 'l1': descs /= np.sum(descs, axis=2)[:, :, np.newaxis] elif normalization == 'l2': descs /= sqrt(np.sum(descs ** 2, axis=2))[:, :, np.newaxis] elif normalization == 'daisy': for i in range(0, desc_dims, orientations): norms = sqrt(np.sum(descs[:, :, i:i + orientations] ** 2, axis=2)) descs[:, :, i:i + orientations] /= norms[:, :, np.newaxis] if visualize: descs_img = skimage.color.gray2rgb(img) for i in range(descs.shape[0]): for j in range(descs.shape[1]): # Draw center histogram sigma color = (1, 0, 0) desc_y = i * step + radius desc_x = j * step + radius coords = draw.circle_perimeter(desc_y, desc_x, int(sigmas[0])) draw.set_color(descs_img, coords, color) max_bin = np.max(descs[i, j, :]) for o_num, o in enumerate(orientation_angles): # Draw center histogram bins bin_size = descs[i, j, o_num] / max_bin dy = sigmas[0] * bin_size * sin(o) dx = sigmas[0] * bin_size * cos(o) coords = draw.line(desc_y, desc_x, int(desc_y + dy), int(desc_x + dx)) draw.set_color(descs_img, coords, color) for r_num, r in enumerate(ring_radii): color_offset = float(1 + r_num) / rings color = (1 - color_offset, 1, color_offset) for t_num, t in enumerate(theta): # Draw ring histogram sigmas hist_y = desc_y + int(round(r * sin(t))) hist_x = desc_x + int(round(r * cos(t))) coords = draw.circle_perimeter(hist_y, hist_x, int(sigmas[r_num + 1])) draw.set_color(descs_img, coords, color) for o_num, o in enumerate(orientation_angles): # Draw histogram bins bin_size = descs[i, j, orientations + r_num * histograms * orientations + t_num * orientations + o_num] bin_size /= max_bin dy = sigmas[r_num + 1] * bin_size * sin(o) dx = sigmas[r_num + 1] * bin_size * cos(o) coords = draw.line(hist_y, hist_x, int(hist_y + dy), int(hist_x + dx)) draw.set_color(descs_img, coords, color) return descs, descs_img else: return descs
accums = [] radii = [] for radius, h in zip(hough_radii, hough_res): # For each radius, extract two circles peaks = peak_local_max(h, num_peaks=2) centers.extend(peaks) accums.extend(h[peaks[:, 0], peaks[:, 1]]) radii.extend([radius, radius]) # Draw the most prominent 5 circles image = color.gray2rgb(image) for idx in np.argsort(accums)[::-1][:5]: center_x, center_y = centers[idx] radius = radii[idx] cx, cy = circle_perimeter(center_y, center_x, radius) image[cy, cx] = (220, 20, 20) ax.imshow(image, cmap=plt.cm.gray) """ .. image:: PLOT2RST.current_figure Ellipse detection ================= In this second example, the aim is to detect the edge of a coffee cup. Basically, this is a projection of a circle, i.e. an ellipse. The problem to solve is much more difficult because five parameters have to be determined, instead of three for circles.
img = io.imread('./circle.png') image_gray = color.rgb2gray(img) im = ndi.gaussian_filter(image_gray, 1.5, mode="reflect") # blur = gaussian(image_gray,0.2) im = img_as_ubyte(im[0:260, 70:280]) edges = canny(im, sigma=2, low_threshold=0.55, high_threshold=0.8) # Detect two radii hough_radii = np.arange(25, 75, 2) hough_res = hough_circle(edges, hough_radii) # Select the most prominent 4 circles accums, cx, cy, radii = hough_circle_peaks(hough_res, hough_radii, total_num_peaks=4) # Draw them fig, ax = plt.subplots(ncols=1, nrows=1, figsize=(20, 20)) ax.set_title('Detected Circles', fontsize=50) # title of plot image = color.gray2rgb(img[0:260, 70:280]) for center_y, center_x, radius in zip(cy, cx, radii): circy, circx = circle_perimeter(center_y, center_x, radius, shape=image.shape) image[circy, circx] = (220, 20, 20) ax.imshow(image, cmap=plt.cm.gray) plt.show()
def mask_to_food_contour(mask, n_bins=90, frac_lowess=0.05, is_debug=False): ''' Estimate the food contour from a binary mask. 1) Get the best the best fit to a circle using the hough transform. 2) Transform the mask into polar coordinates centered in the fitted circle. 3) Get the closest point to the circle using 2*n_bins angles. 4) Smooth using lowess fitting (good to ignore outliers) to estimate the food contour. 5) Transform back into cartesian coordinates. ''' #%% h_res = get_best_circles(mask.copy()) _, cy0, cx0, r0 = h_res[0] (px, py) = np.where(skeletonize(mask)) xx = px - cx0 yy = py - cy0 del_r = np.sqrt(xx * xx + yy * yy) - r0 theta = np.arctan2(xx, yy) theta_d = np.round((theta / np.pi) * n_bins).astype(np.int) #g = {k:[] for k in range(-n_bins, n_bins+1)} g = {k: [] for k in np.unique(theta_d)} for k, dr in zip(theta_d, del_r): g[k].append(dr) _get_min = lambda g: min(g, key=lambda x: abs(x)) if g else np.nan tg, min_dr = zip(*[(k, _get_min(g)) for k, g in g.items()]) theta_s = np.array(tg) * np.pi / n_bins #increase the range for the interpolation theta_i = np.hstack((theta_s - 2 * np.pi, theta_s, theta_s + 2 * np.pi)) r_s = np.hstack((min_dr, min_dr, min_dr)) out = lowess(r_s, theta_i, frac=frac_lowess) #win_frac = 1/3 #filt_w = round(n_bins*win_frac) #filt_w = filt_w+1 if filt_w % 2 == 0 else filt_w #r_s = medfilt(r_s, filt_w) f = interp1d(out[:, 0], out[:, 1]) theta_new = np.linspace(-np.pi, np.pi, 480) r_new = f(theta_new) + r0 circy = r_new * np.cos(theta_new) + cy0 circx = r_new * np.sin(theta_new) + cx0 #%% if is_debug: from skimage.draw import circle_perimeter import matplotlib.pylab as plt plt.figure(figsize=(5, 5)) for ii, (acc, cx, cy, cr) in enumerate(h_res[0:1]): #plt.subplot(3,3,ii+1) plt.imshow(mask) cpy, cpx = circle_perimeter(cy, cx, cr) plt.plot(cpx, cpy, '.r') plt.figure() plt.plot(theta_d, del_r, '.') plt.plot(tg, min_dr) plt.figure() plt.plot(theta_i, r_s, '.') plt.plot(out[:, 0], out[:, 1], '.') #%% return circx, circy, h_res[0]
def auto_find_center_rings(avg_img, sigma=1, no_rings=4, min_samples=3, residual_threshold=1, max_trials=1000): """This will find the center of the speckle pattern and the radii of the most intense rings. Parameters ---------- avg_img : 2D array shape of the image sigma : float, optional Standard deviation of the Gaussian filter. no_rings : int, optional number of rings min_sample : int, optional The minimum number of data points to fit a model to. residual_threshold : float, optional Maximum distance for a data point to be classified as an inlier. max_trials : int, optional Maximum number of iterations for random sample selection. Returns ------- center : tuple center co-ordinates of the speckle pattern image : 2D array Indices of pixels that belong to the rings, directly index into an array radii : list values of the radii of the rings Note ---- scikit-image ransac method(http://www.imagexd.org/tutorial/lessons/1_ransac.html) is used to automatically find the center and the most intense rings. """ image = img_as_float(color.rgb2gray(avg_img)) edges = feature.canny(image, sigma) coords = np.column_stack(np.nonzero(edges)) edge_pts_xy = coords[:, ::-1] radii = [] for i in range(no_rings): model_robust, inliers = ransac(edge_pts_xy, CircleModel, min_samples, residual_threshold, max_trials=max_trials) if i == 0: center = int(model_robust.params[0]), int(model_robust.params[1]) radii.append(model_robust.params[2]) rr, cc = draw.circle_perimeter(center[1], center[0], int(model_robust.params[2]), shape=image.shape) image[rr, cc] = i + 1 edge_pts_xy = edge_pts_xy[-inliers] return center, image, radii
def get(self, idx): img = np.random.randn(*(self.dim + (3, ))) / 5 ri1, ri2, ri3, ri4, ri5, ri6 = np.sign(np.random.randint( -100, 100)) * ((np.random.rand() * 2) + .5), np.sign( np.random.randint(-100, 100)) * ( (np.random.rand() * 2) + .5), (np.random.rand() * 4) + 3, ( np.random.rand() * 4) + 3, np.sign( np.random.randint(-100, 100)) * ( (np.random.rand() * 2) + .5), np.sign( np.random.randint(-100, 100)) * ( (np.random.rand() * 2) + .5) x = np.zeros(self.dim) x[:, :] = np.arange(img.shape[0])[np.newaxis, :] y = x.transpose() img += (np.sin( np.sqrt((x * ri1)**2 + ((self.dim[1] - y) * ri2)**2) * ri3 * np.pi / self.dim[0]))[..., np.newaxis] img += (np.sin( np.sqrt((x * ri5)**2 + ((self.dim[1] - y) * ri6)**2) * ri4 * np.pi / self.dim[1]))[..., np.newaxis] img = gaussian(np.clip(img, 0.1, 1), sigma=.8) circles = [] cmps = [] while len(circles) < self.n_ellips: mp = np.random.randint(self.min_r, self.dim[0] - self.min_r, 2) too_close = False for cmp in cmps: if np.linalg.norm(cmp - mp) < self.min_dist: too_close = True if too_close: continue r = np.random.randint(self.min_r, self.max_r, 2) circles.append(draw.circle(mp[0], mp[1], r[0], shape=self.dim)) cmps.append(mp) polys = [] while len(polys) < self.n_polys: mp = np.random.randint(self.min_r, self.dim[0] - self.min_r, 2) too_close = False for cmp in cmps: if np.linalg.norm(cmp - mp) < self.min_dist // 2: too_close = True if too_close: continue circle = draw.circle_perimeter(mp[0], mp[1], self.max_r) poly_vert = np.random.choice(len(circle[0]), np.random.randint(3, 6), replace=False) polys.append( draw.polygon(circle[0][poly_vert], circle[1][poly_vert], shape=self.dim)) cmps.append(mp) rects = [] while len(rects) < self.n_rect: mp = np.random.randint(self.min_r, self.dim[0] - self.min_r, 2) _len = np.random.randint(self.min_r // 2, self.max_r, (2, )) too_close = False for cmp in cmps: if np.linalg.norm(cmp - mp) < self.min_dist: too_close = True if too_close: continue start = (mp[0] - _len[0], mp[1] - _len[1]) rects.append( draw.rectangle(start, extent=(_len[0] * 2, _len[1] * 2), shape=self.dim)) cmps.append(mp) for poly in polys: color = np.random.rand(3) while np.linalg.norm(color - self.ellips_color ) < self.col_diff or np.linalg.norm( color - self.rect_color) < self.col_diff: color = np.random.rand(3) img[poly[0], poly[1], :] = color img[poly[0], poly[1], :] += np.random.randn(len(poly[1]), 3) / 5 cols = np.random.choice(np.arange(4, 11, 1).astype(np.float) / 10, self.n_ellips, replace=False) for i, ellipse in enumerate(circles): ri1, ri2, ri3, ri4, ri5, ri6 = np.sign(np.random.randint( -100, 100)) * ((np.random.rand() * 4) + 7), np.sign( np.random.randint(-100, 100)) * ( (np.random.rand() * 4) + 7), (np.random.rand() + 1) * 3, (np.random.rand() + 1) * 3, np.sign( np.random.randint(-100, 100)) * ( (np.random.rand() * 4) + 7), np.sign( np.random.randint(-100, 100)) * ( (np.random.rand() * 4) + 7) img[ellipse[0], ellipse[1], :] = np.array([cols[i], 0.0, 0.0]) img[ellipse[0], ellipse[1], :] += np.array([1.0, 1.0, 0.0]) * ((np.sin( np.sqrt((x[ellipse[0], ellipse[1]] * ri5)**2 + ( (self.dim[1] - y[ellipse[0], ellipse[1]]) * ri2)**2) * ri3 * np.pi / self.dim[0]))[..., np.newaxis] * 0.15) + 0.2 img[ellipse[0], ellipse[1], :] += np.array([1.0, 1.0, 0.0]) * ((np.sin( np.sqrt((x[ellipse[0], ellipse[1]] * ri6)**2 + ( (self.dim[1] - y[ellipse[0], ellipse[1]]) * ri1)**2) * ri4 * np.pi / self.dim[1]))[..., np.newaxis] * 0.15) + 0.2 # img[ellipse[0], ellipse[1], :] += np.random.randn(len(ellipse[1]), 3) / 10 cols = np.random.choice(np.arange(4, 11, 1).astype(np.float) / 10, self.n_rect, replace=False) for rect in rects: ri1, ri2, ri3, ri4, ri5, ri6 = np.sign(np.random.randint( -100, 100)) * ((np.random.rand() * 4) + 7), np.sign( np.random.randint(-100, 100)) * ( (np.random.rand() * 4) + 7), (np.random.rand() + 1) * 3, (np.random.rand() + 1) * 3, np.sign( np.random.randint(-100, 100)) * ( (np.random.rand() * 4) + 7), np.sign( np.random.randint(-100, 100)) * ( (np.random.rand() * 4) + 7) img[rect[0], rect[1], :] = np.array([0.0, 0.0, cols[i]]) img[rect[0], rect[1], :] += np.array([1.0, 1.0, 0.0]) * ((np.sin( np.sqrt((x[rect[0], rect[1]] * ri5)**2 + ((self.dim[1] - y[rect[0], rect[1]]) * ri2)**2) * ri3 * np.pi / self.dim[0]))[..., np.newaxis] * 0.15) + 0.2 img[rect[0], rect[1], :] += np.array([1.0, 1.0, 0.0]) * ((np.sin( np.sqrt((x[rect[0], rect[1]] * ri1)**2 + ((self.dim[1] - y[rect[0], rect[1]]) * ri6)**2) * ri4 * np.pi / self.dim[1]))[..., np.newaxis] * 0.15) + 0.2 # img[rect[0], rect[1], :] += np.random.randn(*(rect[1].shape + (3,)))/10 img = np.clip(img, 0, 1).astype(np.float32) smooth_image = gaussian(img, sigma=.2) # shape = np.array(smooth_image.shape[0:2]).astype(np.uint32).tolist() # taggedImg = vigra.taggedView(smooth_image, 'xyc') # edgeStrength = vigra.filters.structureTensorEigenvalues(taggedImg, 1.5, 1.9)[:, :, 0] # edgeStrength = edgeStrength.squeeze() # edgeStrength = np.array(edgeStrength).astype(np.float32) # seeds = vigra.analysis.localMinima(edgeStrength) # seeds = vigra.analysis.labelImageWithBackground(seeds) # gridGraph = nifty.graph.undirectedGridGraph(shape) # # oversegNodeWeighted = nifty.graph.nodeWeightedWatershedsSegmentation(graph=gridGraph, seeds=seeds.ravel(), # # nodeWeights=edgeStrength.ravel()) # # oversegNodeWeighted = oversegNodeWeighted.reshape(shape) # # gridGraphEdgeStrength = gridGraph.imageToEdgeMap(edgeStrength, mode='sum') # np.random.permutation(gridGraphEdgeStrength) # oversegEdgeWeightedA = nifty.graph.edgeWeightedWatershedsSegmentation(graph=gridGraph, seeds=seeds.ravel(), # edgeWeights=gridGraphEdgeStrength) # oversegEdgeWeightedA = oversegEdgeWeightedA.reshape(shape) # interpixelShape = [2 * s - 1 for s in shape] # imgBig = vigra.sampling.resize(taggedImg, interpixelShape) # edgeStrength = vigra.filters.structureTensorEigenvalues(imgBig, 2 * 1.5, 2 * 1.9)[:, :, 0] # edgeStrength = edgeStrength.squeeze() # edgeStrength = np.array(edgeStrength) # gridGraphEdgeStrength = gridGraph.imageToEdgeMap(edgeStrength, mode='interpixel') # oversegEdgeWeightedB = nifty.graph.edgeWeightedWatershedsSegmentation( # graph=gridGraph, # seeds=seeds.ravel(), # edgeWeights=gridGraphEdgeStrength) # oversegEdgeWeightedB = oversegEdgeWeightedB.reshape(shape) affinities = get_naive_affinities(smooth_image, offsets) affinities[:self.sep_chnl] *= -1 affinities[:self.sep_chnl] += +1 affinities[:self.sep_chnl] /= 1.3 affinities[self.sep_chnl:] *= 1.3 affinities = np.clip(affinities, 0, 1) # valid_edges = get_valid_edges((len(self.edge_offsets), ) + self.dim, self.edge_offsets, self.sep_chnl, None, False) node_labeling, neighbors, cutting_edges, mutexes = compute_mws_segmentation_cstm( affinities.ravel(), valid_edges.ravel(), offsets, self.sep_chnl, self.dim) return img, None
edges = canny(c, sigma=1, low_threshold=0.1) fig, ((ax1, ax2),(ax3, ax4)) = plt.subplots(nrows=2, ncols=2, figsize=(12, 7), sharex=True, sharey=True) hough_radii = np.arange(4, 17, 1) hough_res = hough_circle(edges, hough_radii) hough_res = hough_circle(s, hough_radii) Np = 70 accums, cx, cy, radii = hough_circle_peaks(hough_res, hough_radii, min_xdistance=5, min_ydistance=5, total_num_peaks=Np, normalize=True) #,total_num_peaks=3 #print(accums) image = np.zeros((Nx,Ny)) centers = np.zeros((Nx,Ny)) for center_y, center_x, radius, acc in zip(cy, cx, radii, accums): circy, circx = circle_perimeter(center_y, center_x, radius) condlisty = [circy < 0, (circy>=0) & (circy<=Ny-1), circy > Ny-1] condlistx = [circx < 0, (circx>=0) & (circx<=Nx-1), circx > Nx-1] funclist = [lambda x: x+Ny, lambda x: x, lambda x: x-Ny] circy = np.piecewise(circy, condlisty, funclist) circx = np.piecewise(circx, condlistx, funclist) image[center_y,center_x] = acc#1. image[circy, circx]= acc#1. centers[center_y,center_x] = 1 ax1.imshow(image) ax1.axis('off') ax1.set_title('noisy image', fontsize=20) ax2.imshow(centers, cmap=plt.cm.gray) ax2.axis('off')
(220, 590), (300, 300), )) rr, cc = polygon(poly[:, 0], poly[:, 1], img.shape) img[rr, cc, 1] = 1 # fill circle rr, cc = disk((200, 200), 100, shape=img.shape) img[rr, cc, :] = (1, 1, 0) # fill ellipse rr, cc = ellipse(300, 300, 100, 200, img.shape) img[rr, cc, 2] = 1 # circle rr, cc = circle_perimeter(120, 400, 15) img[rr, cc, :] = (1, 0, 0) # Bezier curve rr, cc = bezier_curve(70, 100, 10, 10, 150, 100, 1) img[rr, cc, :] = (1, 0, 0) # ellipses rr, cc = ellipse_perimeter(120, 400, 60, 20, orientation=math.pi / 4.) img[rr, cc, :] = (1, 0, 1) rr, cc = ellipse_perimeter(120, 400, 60, 20, orientation=-math.pi / 4.) img[rr, cc, :] = (0, 0, 1) rr, cc = ellipse_perimeter(120, 400, 60, 20, orientation=math.pi / 2.) img[rr, cc, :] = (1, 1, 1) ax1.imshow(img)
xinterp = np.linspace(0, pSEARCH-1, num=len(temp_profile)*100, endpoint=True) peak_of_interest = np.zeros([nTw])*np.nan for i in range(nTw): profile[:,i] = raw_wavg_reg_bgsub_reg_circavg_sato[i,ctrd_y, ctrd_x:ctrd_x+20] x = np.linspace(0, pSEARCH-1, num=len(temp_profile), endpoint=True) f = interp1d(x, profile[:,i], kind='cubic') profile_interp[:,i] = f(xinterp) peaks, properties = find_peaks(profile_interp[:,i], prominence=0.1) if peaks.size: peak_of_interest[i] = xinterp[peaks[0]] else: peak_of_interest[i] = np.nan tracking_display = np.zeros([nTw,nY,nX]) for i in range(nTw): rr, cc = circle_perimeter(ctrd_y,ctrd_x, (peak_of_interest[i]*1.5).astype('int'), shape=tracking_display[i,:,:].shape) tracking_display[i,:,:][rr, cc] = 1 temp_nan_poi = np.zeros([wAVG//2])*np.nan peak_of_interest = np.concatenate(( temp_nan_poi, peak_of_interest, temp_nan_poi), axis=0 ) temp_nan_im = np.zeros([wAVG//2,nY,nX]) raw_wavg_reg_bgsub_reg = np.concatenate(( temp_nan_im, raw_wavg_reg_bgsub_reg,
def mainTurnHR(): '''1. read img LR and HR''' imgLRPath = '../../github/vrn-07231340/examples/scaled/trump_12.jpg' imgLR = cv2.imread(imgLRPath) imgHRPath = '../../github/vrn-07231340/examples/trump_12.png' imgHR = cv2.imread(imgHRPath) objPath = '../../github/vrn-07231340/obj/trump_12.obj' '''2. img LR --> HR''' zRatio = 3 objLinesHR, vLinesHR, landmarkLR, landmarkHR = lr2hr3DModel( imgLR, imgHR, zRatio, objPath) '''3. HR: origin 2D landmark --> origin 3D landmark''' originLandmark3DList = getLandmark3DHR(landmarkHR, vLinesHR) originLandmark3DList = optionChooseZMax(originLandmark3DList) faceLandmarkVlines = [] for (_, _, (_, vLine)) in originLandmark3DList: faceLandmarkVlines.append(vLine) '''4. HR: collar detection''' _, collarPoint = collarDetection(imgHR, minSize=1200, offset=15) '''5. HR: hair detection''' originHairPoints = hairDetection(imgHR, minSize=20000) '''5.1 hair points 不应该全部都在一个平面上(minZ=200),他们应该在一个曲面上''' ''' 取XZ平面上face landmark的三个极点,画一个圆''' ''' 除了face landmark以外的所有点 的 z,都落到圆上''' '''5.1.1 face landmark上XZ平面的三个极点''' faceLandmarkOnXZ = [] for faceLandmarkVline in faceLandmarkVlines: v, x, y, z, r, g, b = faceLandmarkVline.split() faceLandmarkOnXZ.append((float(x), float(z))) faceLandmarkOnXZMinX = min(faceLandmarkOnXZ, key=lambda x: x[0]) faceLandmarkOnXZMaxX = max(faceLandmarkOnXZ, key=lambda x: x[0]) faceLandmarkOnXZMaxZ = max(faceLandmarkOnXZ, key=lambda x: x[1]) '''5.1.2 三点构成一个圆''' circleCenterXOnXZ, circleCenterZOnXZ, radiusOnXZ = threePoints2Circle( faceLandmarkOnXZMinX, faceLandmarkOnXZMaxX, faceLandmarkOnXZMaxZ) circleCenterZOnXZ = circleCenterZOnXZ-70 '''5.1.3 把这个圆扩大,圆心不动,半径扩大至hair points的极点''' k1 = abs(circleCenterXOnXZ-max(originHairPoints, key=lambda x: x[0])[0]) k2 = abs(circleCenterXOnXZ-min(originHairPoints, key=lambda x: x[0])[0]) radiusOnXZ = max([k1, k2])+5 rr, cc = circle_perimeter(int(circleCenterXOnXZ), int( circleCenterZOnXZ), int(radiusOnXZ)) circleOnXZ = np.dstack([rr, cc])[0] '''5.1.4 hair points 的 z 落在圆上''' hairPointsVlines = [] for (x, y) in originHairPoints: maxZ = 0 for (x0, z0) in circleOnXZ: if int(x) == int(x0): if z0 > maxZ: maxZ = z0 hairVline = '{} {} {} {} {} {} {}'.format('v', x, y, maxZ, 0, 0, 0) hairPointsVlines.append(hairVline) maxZ = 0 assert len(hairPointsVlines) == len(originHairPoints) '''6. HR: face landmarks + hair points''' originVlines = faceLandmarkVlines+hairPointsVlines '''7. HR: turn face and hair''' turnAngle = 10 turnDirection = ['left', 'right'] turnCenterMode = 'maxY' leftTurnVLines = turnHR(originVlines, turnAngle, turnDirection[0], turnCenterMode) rightTurnVLines = turnHR(originVlines, turnAngle, turnDirection[1], turnCenterMode) assert len(originVlines) == len(leftTurnVLines) == len(rightTurnVLines) '''8. HR: turn 3D --> 2D''' originPointsHR = [] leftTurnPointsHR = [] rightTurnPointsHR = [] for originVline, leftTurnVLine, rightTurnVLine in zip(originVlines, leftTurnVLines, rightTurnVLines): _, x, y, _, _, _, _ = originVline.split() originPointsHR.append((float(x), float(y))) _, x, y, _, _, _, _ = leftTurnVLine.split() leftTurnPointsHR.append((float(x), float(y))) _, x, y, _, _, _, _ = rightTurnVLine.split() rightTurnPointsHR.append((float(x), float(y))) assert len(originPointsHR) == len( leftTurnPointsHR) == len(rightTurnPointsHR) # drawPointsOnImg(originPointsHR, imgHR, 'g') # drawPointsOnImg(turnPointsHR, imgHR, 'r') ''''9. inner ellipse''' left = min(originPointsHR, key=lambda x: x[0])[0] right = max(originPointsHR, key=lambda x: x[0])[0] up = min(originPointsHR, key=lambda x: x[1])[1] bottom = max(originPointsHR, key=lambda x: x[1])[1] innerEllipseCenterX = int((left+right)/2.0) innerEllipseCenterY = int((up+bottom)/2.0) innerEllipseSemiX = int((right-left)/2.0) innerEllipseSemiY = int((bottom-up)/2.0) rr, cc = ellipse_perimeter(innerEllipseCenterX, innerEllipseCenterY, innerEllipseSemiY, innerEllipseSemiX, orientation=np.pi*1.5) innerEllipseVerts = np.dstack([rr, cc])[0] '''10. outer ellipse''' '''10.1 ratio = outer ellipse / inner ellipse''' ''' 椭圆心和衣领的线段 和 椭圆的交点''' minDistance = np.inf for pt in innerEllipseVerts: distance = twoPointsDistance(pt, collarPoint) if distance < minDistance: minDistance = distance ratio = twoPointsDistance((innerEllipseCenterX, innerEllipseCenterY), collarPoint) / \ twoPointsDistance( (innerEllipseCenterX, innerEllipseCenterY), pt) '''10.2 outer ellipse''' outerEllipseSemiX = int(ratio*innerEllipseSemiX) outerEllipseSemiY = int(ratio*innerEllipseSemiY) rr, cc = ellipse_perimeter(innerEllipseCenterX, innerEllipseCenterY, outerEllipseSemiY, outerEllipseSemiX, orientation=np.pi*1.5) outerEllipseVerts = np.dstack([rr, cc])[0] # drawPointsOnImg(outerEllipseVerts, imgHR, 'g') '''11. edge points on outer ellipse''' edgePoints = edgePointsOnOuterEllipse(outerEllipseVerts) '''12. final origin and turn points''' originPointsHRFinal = originPointsHR+edgePoints leftTurnPointsHRFinal = leftTurnPointsHR+edgePoints rightTurnPointsHRFinal = rightTurnPointsHR+edgePoints '''13. tri.txt''' triList = generateTriList( originPointsHRFinal, imgHR, triTxtPath='./turnTri.txt') '''14. warp''' # imgMorph = morph_modify_for_2D3D2D_low_resolution( # originPointsHRFinal, turnPointsHRFinal, imgHR, triList) # imshow('imgMorph', imgMorph) # cv2.imwrite('./imgMorph.png', imgMorph) return originPointsHRFinal, leftTurnPointsHRFinal, rightTurnPointsHRFinal, triList