def align_img(image_name, loss_fn=sum_of_squared_diff, max_disp = 15, big=False, name=None, hist_eq = False): b,g,r = get_bgr(image_name) if hist_eq == True: b, g, r = exposure.equalize_hist(b), exposure.equalize_hist(g), exposure.equalize_hist(r) print("Aligning green and blue: ") ag = align(g, b, loss_fn=loss_fn, max_disp = max_disp, big=big, name=name) print("Aligning blue and red: ") ar = align(r, b, loss_fn=loss_fn, max_disp = max_disp, big=big, name=name) # create a color image im_out = np.dstack([ar, ag, b]) plt.show() # save the image iname = image_name.split('.') iname[-1] = 'jpg' image_name = '.'.join(iname) fname = 'out_' + image_name skio.imsave(fname, im_out) # display the image skio.imshow(im_out) plt.show() skio.show()
def save_segmented_image(self, filepath_image, modality='t1c', show=False): ''' Creates an image of original brain with segmentation overlay and save it in ./predictions INPUT (1) str 'filepath_image': filepath to test image for segmentation, including file extension (2) str 'modality': imaging modality to use as background. defaults to t1c. options: (flair, t1, t1c, t2) (3) bool 'show': If true, shows output image. defaults to False. OUTPUT (1) if show is True, shows image of segmentation results (2) if show is false, returns segmented image. ''' modes = {'flair': 0, 't1': 1, 't1c': 2, 't2': 3} segmentation = self.predict_image(filepath_image, show=False) print 'segmentation = ' + str(segmentation) img_mask = np.pad(segmentation, (16, 16), mode='edge') ones = np.argwhere(img_mask == 1) twos = np.argwhere(img_mask == 2) threes = np.argwhere(img_mask == 3) fours = np.argwhere(img_mask == 4) test_im = io.imread(filepath_image) test_back = test_im.reshape(5, 216, 160)[modes[modality]] # overlay = mark_boundaries(test_back, img_mask) gray_img = img_as_float(test_back) # adjust gamma of image image = adjust_gamma(color.gray2rgb(gray_img), 0.65) sliced_image = image.copy() red_multiplier = [1, 0.2, 0.2] yellow_multiplier = [1, 1, 0.25] green_multiplier = [0.35, 0.75, 0.25] blue_multiplier = [0, 0.25, 0.9] print str(len(ones)) print str(len(twos)) print str(len(threes)) print str(len(fours)) # change colors of segmented classes for i in xrange(len(ones)): sliced_image[ones[i][0]][ones[i][1]] = red_multiplier for i in xrange(len(twos)): sliced_image[twos[i][0]][twos[i][1]] = green_multiplier for i in xrange(len(threes)): sliced_image[threes[i][0]][threes[i][1]] = blue_multiplier for i in xrange(len(fours)): sliced_image[fours[i][0]][fours[i][1]] = yellow_multiplier #if show=True show the prediction if show: print 'Showing...' io.imshow(sliced_image) plt.show() #save the prediction print 'Saving...' try: mkdir_p('./predictions/') io.imsave('./predictions/' + os.path.basename(filepath_image) + '.png', sliced_image) print 'prediction saved.' except: io.imsave('./predictions/' + os.path.basename(filepath_image) + '.png', sliced_image) print 'prediction saved.'
def hsi_equalize_hist(): image=data.astronaut() h=color.rgb2hsv(image) h[:,:,2]=exposure.equalize_hist(h[:,:,2]) image_equal=color.hsv2rgb(h) io.imshow(image_equal) io.imsave('astronautequal.png',image_equal)
def PreprocessImage(path, show_img=False): # load image img = io.imread(path) print("Original Image Shape: ", img.shape) # we crop image from center short_egde = min(img.shape[:2]) yy = int((img.shape[0] - short_egde) / 2) xx = int((img.shape[1] - short_egde) / 2) crop_img = img[yy : yy + short_egde, xx : xx + short_egde] # resize to 224, 224 resized_img = transform.resize(crop_img, (224, 224)) if show_img: io.imshow(resized_img) # convert to numpy.ndarray sample = np.asarray(resized_img) * 256 # swap channel from RGB to BGR sample = sample[:, :, [2,1,0]] # swap axes to make image from (224, 224, 4) to (3, 224, 224) sample = np.swapaxes(sample, 0, 2) sample = np.swapaxes(sample, 1, 2) # sub mean normed_img = sample - mean_img normed_img.resize(1, 3, 224, 224) return normed_img
def threshold_image(image, threshold=0): """ This function takes out any values in an image's RGB matrix that are below the threshold value. Inputs: - image: a matrix describing an image with only one channel represented. - threshold: a value, between 0 and 1, for which if an image matrix's value is below, will be set to 0, and if above, will be set to 1. If the threshold is set to 0, then an Otsu thresholding will be returned. Outputs: - thresholded_image: a matrix representation of the thresholded image. this is essentially a black and white image. - thresh: the threshold value To screen: the black-and-white image representation. - """ if threshold == 0: thresh = threshold_otsu(image) if threshold != 0: thresh = threshold thresholded_image = closing(image > thresh, square(3), out=None) imshow(thresholded_image) return thresholded_image, thresh
def main(): imgs = MultiImage(data_dir + '/multipage.tif') for a, i in zip(range(0, 4), [1, 9, 7, 8]): fig = plt.figure() ax = fig.add_axes([-0.1, -0.1, 1.2, 1.2]) # ax.set_axis_off() im = data.imread('samolot0' + str(i) + '.jpg', as_grey = True) im = invert(im) im = process(im) out = np.ones_like(im) io.imshow(out) contours = measure.find_contours(im, 0.9) for n, contour in enumerate(contours): plt.plot(contour[:, 1], contour[:, 0], linewidth=2, color = 'white') plt.savefig(str(a) + '.jpg', bbox_inches = 0, frameon = False) fig = plt.figure() grid = AxesGrid(fig, rect = (1, 1, 1), nrows_ncols = (2, 2), axes_pad = 0.1) for i in range(0, 4): frame = data.imread(str(i) + '.jpg') grid[i].imshow(frame) grid[i].set_xticks([]) grid[i].set_yticks([]) plt.savefig('na3.jpg')
def transform(self, func, params, sub_dir=None, img_ind=None): """ Takes a function and apply to every img_arr in self.img_arr. Have to option to transform one as a test case :param sub_dir: The index for the image :param img_ind: The index of the category of images """ # Apply to one test case if sub_dir is not None and img_ind is not None: sub_dir_ind = self.label_map[sub_dir] img_arr = self.img_lst2[sub_dir_ind][img_ind] img_arr = func(img_arr, **params).astype(float) io.imshow(img_arr) plt.show() # Apply the function and parameters to all the images elif isinstance(sub_dir, list): if len(sub_dir) == 1: sub_dir_ind = self.label_map[sub_dir[0]] new_img_lst2 = [] for img_arr in self.img_lst2[sub_dir_ind]: new_img_lst2.append(func(img_arr, **params).astype(float)) self.img_lst2[sub_dir_ind] = new_img_lst2 else: for dir in sub_dir: sub_dir_ind = self.label_map[dir] new_img_lst2 = [] for img_arr in self.img_lst2[sub_dir_ind]: new_img_lst2.append(func(img_arr, **params).astype(float)) self.img_lst2[sub_dir_ind] = new_img_lst2 else: new_img_lst2 = [] for img_lst in self.img_lst2: new_img_lst2.append([func(img_arr, **params).astype(float) for img_arr in img_lst]) self.img_lst2 = new_img_lst2
def detectOpticDisc(image): kernel = octagon(10, 10) thresh = threshold_otsu(image[:,:,1]) binary = image > thresh print binary.dtype luminance = convertToHLS(image)[:,:,2] t = threshold_otsu(luminance) t = erosion(luminance, kernel) labels = segmentation.slic(image[:,:,1], n_segments = 3) out = color.label2rgb(labels, image[:,:,1], kind='avg') skio.imshow(out) x, y = computeCentroid(t) print x, y rows, cols, _ = image.shape p1 = closing(image[:,:,1],kernel) p2 = opening(p1, kernel) p3 = reconstruction(p2, p1, 'dilation') p3 = p3.astype(np.uint8) #g = dilation(p3, kernel)-erosion(p3, kernel) #g = rank.gradient(p3, disk(5)) g = cv2.morphologyEx(p3, cv2.MORPH_GRADIENT, kernel) #markers = rank.gradient(p3, disk(5)) < 10 markers = drawCircle(rows, cols, x, y, 85) #markers = ndimage.label(markers)[0] #skio.imshow(markers) g = g.astype(np.uint8) #g = cv2.cvtColor(g, cv2.COLOR_GRAY2RGB) w = watershed(g, markers) print np.max(w), np.min(w) w = w.astype(np.uint8) #skio.imshow(w) return w
def doit(filename): dat = io.imread(filename) dat = rgb2gray(dat) blobs = blob_dog(dat, max_sigma=12, threshold=.25) blobs[:, 2] = blobs[:, 2] * (2 ** 0.5) io.imshow(dat) for blob in blobs: y, x, r = blob c = plt.Circle((x, y), r, color='r', linewidth=2, fill=False) plt.gca().add_patch(c) plt.show() print (blobs[:,2].size) r = (blobs[:,2]) print (r) print (area_of_circle(r)) avg_area = np.mean(area_of_circle(r)) print (avg_area) #Distance from average x avg_x = np.mean(blobs[:,0]) x = (blobs[:,0]) x_dist = (x-avg_x) print (x_dist) #Distance from average y avg_y = np.mean(blobs[:,1]) y = (blobs[:,1]) y_dist = (y-avg_y) print (y_dist) return blobs # for potential further processing
def draw_window(frame): # setup initial location of window r,h,c,w = 250,90,400,125 # simply hardcoded the values track_window = (c,r,w,h) # set up the ROI for tracking roi = frame[r:r+h, c:c+w] hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) mask = cv2.inRange(hsv_roi, np.array((0., 60.,32.)), np.array((180.,255.,255.))) roi_hist = cv2.calcHist([hsv_roi],[0],mask,[180],[0,180]) cv2.normalize(roi_hist,roi_hist,0,255,cv2.NORM_MINMAX) # Setup the termination criteria, either 10 iteration or move by atleast 1 pt term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 ) hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) dst = cv2.calcBackProject([hsv],[0],roi_hist,[0,180],1) # apply meanshift to get the new location ret, track_window = cv2.CamShift(dst, track_window, term_crit) # Draw it on image pts = cv2.boxPoints(ret) pts = np.int0(pts) img2 = cv2.polylines(frame,[pts],True, 255,2) io.imshow(img2)
def main(): args = vars(parser.parse_args()) filename = os.path.join(os.getcwd(), args["image"][0]) image = skimage.img_as_uint(color.rgb2gray(io.imread(filename))) subsample = 1 if (not args["subsample"] == 1): subsample = args["subsample"][0] image = transform.downscale_local_mean(image, (subsample, subsample)) image = transform.pyramid_expand(image, subsample, 0, 0) image = exposure.rescale_intensity(image, out_range=(0,args["depth"][0])) if (args["visualize"]): io.imshow(image) io.show() source = generate_face(image, subsample, args["depth"][0], FLICKER_SPEED) if source: with open(args["output"][0], 'w') as file_: file_.write(source) else: print "Attempted to generate source code, failed."
def predict_image(self, test_img, show=False): ''' predicts classes of input image INPUT (1) str 'test_image': filepath to image to predict on (2) bool 'show': True to show the results of prediction, False to return prediction OUTPUT (1) if show == False: array of predicted pixel classes for the center 208 x 208 pixels (2) if show == True: displays segmentation results ''' imgs = io.imread(test_img).astype('float').reshape(5,240,240) plist = [] # create patches from an entire slice for img in imgs[:-1]: if np.max(img) != 0: img /= np.max(img) p = extract_patches_2d(img, (33,33)) plist.append(p) patches = np.array(zip(np.array(plist[0]), np.array(plist[1]), np.array(plist[2]), np.array(plist[3]))) # predict classes of each pixel based on model full_pred = self.model_comp.predict_classes(patches) fp1 = full_pred.reshape(208,208) if show: io.imshow(fp1) plt.show else: return fp1
def test(frame): hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) lower_white = np.array([0,0,200]) upper_white = np.array([300,100,300]) # Threshold the HSV image to get only white colors mask = cv2.inRange(hsv, lower_white, upper_white) gray = cv2.cvtColor(mask, cv2.COLOR_BAYER_GB2GRAY) gradX = cv2.Sobel(gray, ddepth = cv2.CV_32F, dx = 1, dy = 0, ksize = -1) gradY = cv2.Sobel(gray, ddepth = cv2.CV_32F, dx = 0, dy = 1, ksize = -1) # subtract the y-gradient from the x-gradient gradient = cv2.subtract(gradX, gradY) gradient = cv2.convertScaleAbs(gradient) # blur and threshold the image blurred=cv2.blur(gray,(9,9)) blurred = cv2.blur(gradient, (9, 9)) (_, thresh) = cv2.threshold(blurred, 225, 255, cv2.THRESH_BINARY) kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (21, 7)) closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel) # perform a series of erosions and dilations closed = cv2.erode(closed, None, iterations = 4) closed = cv2.dilate(closed, None, iterations = 4) image, contours,hierarchy= cv2.findContours(closed, cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE) img= cv2.drawContours(frame, contours, -1,(0,0,0),3) io.imshow(img)
def background_sub(frame): ''' out ''' return gray io.imshow(img)
def show_user_imgs(imgs): ''' Display images to new_user and prompt for response (Like / NoLike) Keep track of preferences in a list. INPUT: list of pairs, (username, img_id) OUTPUT: np.array of new_user's preferences (zero or one) ''' # initialize the list of preferences likes = [] for img in imgs: # generate the path to the image fname = '../imgs/{}'.format(img) # update status to terminal print fname # show image to user imshow(fname) plt.show() # initialize string of preferences pref = '' # logical xor in python is != ... i know, right?? while not pref in ['0', '1']: # survey whether user liked photo print 'you entered: {}'.format(pref) pref = raw_input('Did you like that photo? Yes:1, No:0...') # keep track of the result in list 'likes' likes.append(int(pref)) # convert list 'likes' to np.array for better handling downstream likes = np.array(likes).astype('bool') return likes
def just_do_it(limit_cont): fig = plt.figure(facecolor='black') plt.gray() print("Rozpoczynam przetwarzanie obrazow...") for i in range(20): img = data.imread(images[i]) gray_img = to_gray(images[i]) # samoloty1.pdf #gray_img = to_gray2(images[i], 1001, 0.2, 5, 9, 12) # samoloty2.pdf #gray_img = to_gray2(images[i], 641, 0.2, 5, 20, 5) # samoloty3.pdf conts = find_contours(gray_img, limit_cont) centrs = [find_centroid(cont) for cont in conts] ax = fig.add_subplot(4,5,i) ax.set_yticks([]) ax.set_xticks([]) io.imshow(img) print("Przetworzono: " + images[i]) for n, cont in enumerate(conts): ax.plot(cont[:, 1], cont[:, 0], linewidth=2) for centr in centrs: ax.add_artist(plt.Circle(centr, 5, color='white')) fig.tight_layout() #plt.show() plt.savefig('samoloty3.pdf')
def recognize(breaker, show, sample, LEVEL, THRESHOLD): img = io.imread(sample) if show: io.imshow(img, 'pil') res = '' for cat in breaker.match(img, LEVEL, THRESHOLD): res += cat.name print res
def main(): from skimage import data, io, filters testfolder='/Users/davidgreenfield/Downloads/pics_boots/' testimage='B00A0GVP8A.jpg' image = io.imread(testfolder+testimage,flatten=True) # or any NumPy array! edges = filters.sobel(image) io.imshow(edges) io.show()
def get_rect(path): e, img = detect(path) img = img[40:, :] imshow(img) # import Image # im = Image.fromarray(img) # im.save("your_file.jpg") return img
def testing_result_2(obj, obj2): '''obj = hand2_cascade.detectMultiScale(closed) ''' a = obj2 for (x,y,w,h) in obj: # draw rectangle at the specific location cv2.rectangle(a,(x,y),(x+w,y+h),(255,0,0),2) # extract the segmentation io.imshow(a)
def _detect_spots_hough_circle(image, radius): edges = canny(image) imshow(edges) show() hough_radii = np.arange(radius/2, radius*2, 10) hough_circles = hough_circle(edges, hough_radii) print(hough_circles)
def doEigengesichter(self,pos): dim = int(math.sqrt(self.VT.shape[1])) mdata = np.zeros((dim,dim)) imageVector = self.VT[pos,:] for i in range(0,len(imageVector),int(dim)): row = np.array(imageVector)[i:i+dim] mdata[int(i/dim),:] = row io.imshow(mdata)
def color_transformation(): # 彩色变换 image=data.coffee() brighter=np.uint8(image*0.5+255*0.5) darker=np.uint8(image*0.5) io.imshow(brighter) io.show() io.imshow(darker) io.show()
def adapative_threshold(image, block_size=100): """ This method returns the adaptively-thresholded image. """ thresholded_image = threshold_adaptive(image, block_size) imshow(thresholded_image) return thresholded_image
def show_connectivity_matrix(image, cmap=None): """ @param image: 2D ndarray @param cmap: colormap """ if cmap is None: cmap = cm.jet skio.imshow(image, cmap=cmap)
def predict_image(self, filepath_image, show=False): ''' predicts classes of input image INPUT (1) str 'filepath_image': filepath to image to predict on (2) bool 'show': True to show the results of prediction, False to return prediction OUTPUT (1) if show == False: array of predicted pixel classes for the center 208 x 208 pixels (2) if show == True: displays segmentation results ''' print 'Starting prediction...' if self.cascade_model: images = io.imread(filepath_image).astype('float').reshape(5, 216, 160) p33list = [] p65list = [] # create patches from an entire slice for image in images[:-1]: if np.max(image) != 0: image /= np.max(image) patch65 = extract_patches_2d(image, (65, 65)) p65list.append(patch65) p33list.append(self.center_n(33, patch65)) print str(len(p33list)) patches33 = np.array(zip(p33list[0], p33list[1], p33list[2], p33list[3])) patches65 = np.array(zip(p65list[0], p65list[1], p65list[2], p65list[3])) # predict classes of each pixel based on model prediction = self.model.predict([patches65, patches33]) print 'Predicted' prediction = prediction.reshape(208, 208) if show: io.imshow(prediction) plt.show else: return prediction else: images = io.imread(filepath_image).astype('float').reshape(5, 216, 160) p33list = [] # create patches from an entire slice for image in images[:-1]: if np.max(image) != 0: image /= np.max(image) patch33 = extract_patches_2d(image, (33, 33)) p33list.append(patch33) patches33 = np.array(zip(p33list[0], p33list[1], p33list[2], p33list[3])) # predict classes of each pixel based on model prediction = self.cnn1.predict(patches33) print 'Predicted' prediction = prediction.reshape(5, 184, 128) predicted_classes = np.argmax(prediction, axis=0) if show: print 'Let s show' for i in range(5): io.imshow(prediction[i]) plt.show print 'Showed' return prediction else: return predicted_classes
def paint(): fig = plt.figure(facecolor='black') for i in range(0,len(files)): contourImage = getContourImage(files[i]) ax = fig.add_subplot(2,3,i) ax.set_xticks([]) ax.set_yticks([]) io.imshow(contourImage) fig.tight_layout() plt.show()
def main(): os.chdir("daneA/set0") for file in glob.glob("*.png"): img = normalize_one_picture(file) io.imshow(img) print(file) io.show() return 0
def main(argv): filename = argv[1] img = io.imread(filename, as_grey=True) lpyra = tuple(transform.pyramid_laplacian(img)) l = lpyra[0] l = exposure.equalize_hist(l) y, x = np.indices((l.shape[0],l.shape[1])) vect = np.array(zip(y.reshape(y.size),x.reshape(x.size),l.reshape(l.size))) io.imshow(l) io.show()
def show(self, sub_dir, img_ind): """ View the nth image in the nth class :param sub_dir: The name of the category :param img_ind: The index of the category of images """ sub_dir_ind = self.label_map[sub_dir] io.imshow(self.img_lst2[sub_dir_ind][img_ind]) plt.show()
# print(img_rec) # print(img_gray) # print(maxm) # io.imshow(img_rec) # cnt = 0 # for i in range(512): # for j in range(512): # if img_rec[i][j] != img_gray[i][j]: # cnt += 1 # print(cnt) # 23万 im_uint8 = img_as_ubyte(img_rec) io.imsave("嵌入水印的图像.jpg",im_uint8) io.imshow(img_rec) # print(im_uint8) print(num1) #4000上下 img_embedded = io.imread('嵌入水印的图像.jpg') # img_embedded = img_rec watermark = np.zeros([64,64]) for y in range(64): for x in range(64): block = np.zeros([8,8]) for i in range(8): block[i] = img_embedded[y*8+i][8*x:8*(x+1)] coeffs1 = pywt.dwt2(block, 'haar') # 进行两次小波变换 cA, (cH, cV, cD) = coeffs1 coeffs2 = pywt.dwt2(cA, 'haar') cA, (cH, cV, cD) = coeffs2
from skimage import io import numpy as np import cv2 file_path = "./img/img.jpg" image = cv2.imread(file_path, cv2.IMREAD_GRAYSCALE) m, n = image.shape # 原本L应该时一个对称矩阵,此时则将对称矩阵的对角线元素以一维数组形式输出 # P (m, m) # L (m,) # Q (n, n) P, L, Q = np.linalg.svd(image) print(P.shape) print(Q.shape) # L为800的一位数组,使用diag()输出以L为对角线的矩阵 tmp = np.diag(L) if m < n: # 水平堆叠,目的就是为了将d扩充为mxn大小 d = np.hstack((tmp, np.zeros((m, n - m)))) else: # 垂直堆叠 d = np.vstack((tmp, np.zeros((m - n, n)))) k = 50 image2 = P[:, :k].dot(d[:k, :k]).dot(Q[:k, :]) io.imshow(np.uint8(image2)) plt.show()
# read in the image im = skio.imread(imname) # convert to double (might want to do this later on to save memory) im = sk.img_as_float(im) # compute the height of each part (just 1/3 of total) height = np.floor(im.shape[0] / 3.0).astype(np.int) # separate color channels b = im[:height] g = im[height:2 * height] r = im[2 * height:3 * height] # align the images # functions that might be useful for aligning the images include: # np.roll, np.sum, sk.transform.rescale (for multiscale) ### ag = align(g, b) ### ar = align(r, b) # create a color image im_out = np.dstack([ar, ag, b]) # save the image fname = '/out_path/out_fname.jpg' skio.imsave(fname, im_out) # display the image skio.imshow(im_out) skio.show()
return sparse_array # mask_keep = depth > 0 # if max_depth is not np.inf: # mask_keep = np.bitwise_and(mask_keep, depth <= max_depth) # n_keep = np.count_nonzero(mask_keep) # if n_keep == 0: # io.imshow(mask_keep, interpolation='nearest') # io.show() # return mask_keep # else: # prob = float(num_samples) / n_keep # io.imshow(np.bitwise_and(mask_keep, np.random.uniform(0, 1, depth.shape) < prob), interpolation='nearest') # io.show() # return np.bitwise_and(mask_keep, np.random.uniform(0, 1, depth.shape) < prob) rgb1, depth1 = h5_loader(path1) depth_sparse = dense_to_sparse(depth1) io.imshow(depth_sparse, interpolation='nearest') io.show() print(np.amax(depth_sparse)) io.imshow(depth1) # io.imshow(rgb1/255) io.show() # cv2.imshow('', rgb1) # cv2.waitKey()
def performDetect( imagePath="/home/snuzero1/darknet/x64/data/obj/pylon_camera_node-000220-1540444604.221.jpg", thresh=0.25, configPath="/home/snuzero1/darknet/yolo-obj.cfg", weightPath="/home/snuzero1/darknet/backup/yolo-obj_last.weights", metaPath="/home/snuzero1/darknet/x64/data/obj.data", showImage=True, makeImageOnly=False, initOnly=False): """ Convenience function to handle the detection and returns of objects. Displaying bounding boxes requires libraries scikit-image and numpy Parameters ---------------- imagePath: str Path to the image to evaluate. Raises ValueError if not found thresh: float (default= 0.25) The detection threshold configPath: str Path to the configuration file. Raises ValueError if not found weightPath: str Path to the weights file. Raises ValueError if not found metaPath: str Path to the data file. Raises ValueError if not found showImage: bool (default= True) Compute (and show) bounding boxes. Changes return. makeImageOnly: bool (default= False) If showImage is True, this won't actually *show* the image, but will create the array and return it. initOnly: bool (default= False) Only initialize globals. Don't actually run a prediction. Returns ---------------------- When showImage is False, list of tuples like ('obj_label', confidence, (bounding_box_x_px, bounding_box_y_px, bounding_box_width_px, bounding_box_height_px)) The X and Y coordinates are from the center of the bounding box. Subtract half the width or height to get the lower corner. Otherwise, a dict with { "detections": as above "image": a numpy array representing an image, compatible with scikit-image "caption": an image caption } """ # Import the global variables. This lets us instance Darknet once, then just call performDetect() again without instancing again global metaMain, netMain, altNames #pylint: disable=W0603 assert 0 < thresh < 1, "Threshold should be a float between zero and one (non-inclusive)" if not os.path.exists(configPath): raise ValueError("Invalid config path `" + os.path.abspath(configPath) + "`") if not os.path.exists(weightPath): raise ValueError("Invalid weight path `" + os.path.abspath(weightPath) + "`") if not os.path.exists(metaPath): raise ValueError("Invalid data file path `" + os.path.abspath(metaPath) + "`") if netMain is None: netMain = load_net_custom(configPath.encode("ascii"), weightPath.encode("ascii"), 0, 1) # batch size = 1 if metaMain is None: metaMain = load_meta(metaPath.encode("ascii")) if altNames is None: # In Python 3, the metafile default access craps out on Windows (but not Linux) # Read the names file and create a list to feed to detect try: with open(metaPath) as metaFH: metaContents = metaFH.read() import re match = re.search("names *= *(.*)$", metaContents, re.IGNORECASE | re.MULTILINE) if match: result = match.group(1) else: result = None try: if os.path.exists(result): with open(result) as namesFH: namesList = namesFH.read().strip().split("\n") altNames = [x.strip() for x in namesList] except TypeError: pass except Exception: pass if initOnly: print("Initialized detector") return None if not os.path.exists(imagePath): raise ValueError("Invalid image path `" + os.path.abspath(imagePath) + "`") # Do the detection #detections = detect(netMain, metaMain, imagePath, thresh) # if is used cv2.imread(image) detections = detect(netMain, metaMain, imagePath.encode("ascii"), thresh) if showImage: try: from skimage import io, draw import numpy as np image = io.imread(imagePath) print("*** " + str(len(detections)) + " Results, color coded by confidence ***") imcaption = [] for detection in detections: label = detection[0] confidence = detection[1] pstring = label + ": " + str(np.rint(100 * confidence)) + "%" imcaption.append(pstring) print(pstring) bounds = detection[2] shape = image.shape # x = shape[1] # xExtent = int(x * bounds[2] / 100) # y = shape[0] # yExtent = int(y * bounds[3] / 100) yExtent = int(bounds[3]) xEntent = int(bounds[2]) # Coordinates are around the center xCoord = int(bounds[0] - bounds[2] / 2) yCoord = int(bounds[1] - bounds[3] / 2) boundingBox = [[xCoord, yCoord], [xCoord, yCoord + yExtent], [xCoord + xEntent, yCoord + yExtent], [xCoord + xEntent, yCoord]] # Wiggle it around to make a 3px border rr, cc = draw.polygon_perimeter([x[1] for x in boundingBox], [x[0] for x in boundingBox], shape=shape) rr2, cc2 = draw.polygon_perimeter( [x[1] + 1 for x in boundingBox], [x[0] for x in boundingBox], shape=shape) rr3, cc3 = draw.polygon_perimeter( [x[1] - 1 for x in boundingBox], [x[0] for x in boundingBox], shape=shape) rr4, cc4 = draw.polygon_perimeter( [x[1] for x in boundingBox], [x[0] + 1 for x in boundingBox], shape=shape) rr5, cc5 = draw.polygon_perimeter( [x[1] for x in boundingBox], [x[0] - 1 for x in boundingBox], shape=shape) boxColor = (int(255 * (1 - (confidence**2))), int(255 * (confidence**2)), 0) draw.set_color(image, (rr, cc), boxColor, alpha=0.8) draw.set_color(image, (rr2, cc2), boxColor, alpha=0.8) draw.set_color(image, (rr3, cc3), boxColor, alpha=0.8) draw.set_color(image, (rr4, cc4), boxColor, alpha=0.8) draw.set_color(image, (rr5, cc5), boxColor, alpha=0.8) if not makeImageOnly: io.imshow(image) io.show() detections = { "detections": detections, "image": image, "caption": "\n<br/>".join(imcaption) } except Exception as e: print("Unable to show image: " + str(e)) return detections
def show_pic(img): imshow(img) show()
import skimage.io as io def img_unbg(img): w = img.shape[0] h = img.shape[1] ub_img = img.copy() print("calculate...") for i in range(w): for j in range(h): if img[i, j, 0] == 0 & img[i, j, 1] == 0 & img[i, j, 2] == 0: ub_img[i, j, 3] = 0 return ub_img if __name__ == '__main__': root_dir = 'C:/Users/Administrator/Desktop/666/' img_path = root_dir + '*.bmp' # coll = io.ImageCollection(str, load_func=transparent_back) coll = io.ImageCollection(img_path) for i in range(len(coll)): print("All:%d, processing:%d" % (len(coll), i + 1)) # img = transparent_back(coll[i]) img = img_unbg(coll[i]) io.imsave(root_dir + str(i) + '.png', img) print("Image %d have saved!" % i) io.imshow(coll[0]) io.show() print("All image have saved.")
p = np.zeros([670, 128, 128], dtype=np.uint8) for i in range(670): pixel = Y_train[i] for m in range(128): for n in range(128): if (pixel[m, n]): p[i, m, n] = 1 else: p[i, m, n] = 0 #%% Y_train = keras.utils.to_categorical(p, 2) #%% weight_mask = np.ones([670, 128, 128], dtype=np.float32) #%% ix = random.randint(0, len(train_ids)) imshow(X_train[ix]) plt.show() imshow(np.squeeze(Y_train[ix])) plt.show() #%% def mean_iou(y_true, y_pred): prec = [] for t in np.arange(0.5, 1.0, 0.05): y_pred_ = tf.to_int32(y_pred > t) score, up_opt = tf.metrics.mean_iou(y_true, y_pred_, 2) K.get_session().run(tf.local_variables_initializer()) with tf.control_dependencies([up_opt]): score = tf.identity(score) prec.append(score)
from skimage import io npImg1 = cv2.imread("einstein.png") img1 = torch.from_numpy(np.rollaxis(npImg1, 2)).float().unsqueeze(0) / 255.0 img2 = torch.rand(img1.size()) if torch.cuda.is_available(): img1 = img1.cuda() img2 = img2.cuda() img1 = Variable(img1, requires_grad=False) img2 = Variable(img2, requires_grad=True) ssim_value = ssim(img1, img2).item() print("Initial ssim:", ssim_value) ssim_loss = SSIMLoss() optimizer = optim.Adam([img2], lr=0.01) while ssim_value < 0.99: optimizer.zero_grad() ssim_out = -ssim_loss(img1, img2) ssim_value = -ssim_out.item() print('{:<4.4f}'.format(ssim_value)) ssim_out.backward() optimizer.step() img = np.transpose(img2.detach().cpu().squeeze().float().numpy(), (1, 2, 0)) io.imshow(np.uint8(np.clip(img * 255, 0, 255)))
return images, labels train_data_dir = '/home/research_centre_gpu/train' validation_data_dir = '/home/research_centre_gpu/test' images, labels = load_data(train_data_dir) val_images, val_labels = load_data(validation_data_dir) images_64 = np.array(images).astype(np.float32) labels_64 = np.array(labels) val_images_64 = np.array(val_images).astype(np.float32) #uint8 newly added val_labels_64 = np.array(val_labels) io.imshow(images_64[1050]) io.imshow(val_images_64[1050]) #images_64 = images_64/255 #val_images_64 = val_images_64/255 #pt='/home/bhagu/Documents/sohail/data/segmented/training_set/1/8c1a0a73-26c9-405e-8957-8dd58df6bdf4___GCREC_Bact.Sp 3738_final_masked.jpg' #test_img=data.imread(pt) #ri=test_img * 255 #test_img2=np.array(test_img).astype(np.uint8) # #test_img2 = test_img2/255 #print(test_img2[10]) ##val_images_64 = val_images_64/255 #io.imshow(test_img) #io.imshow(test_img2)
def extractFeatures(): imageNames = ['a', 'd', 'f', 'h', 'k', 'm', 'n', 'o', 'p', 'q', 'r', 's', 'u', 'w', 'x', 'z'] #imageNames = ['a'] Features = [] featuresLabels = [] for name in imageNames: # Reading an Image File img = io.imread(name + '.bmp') #print img.shape # Visualizing an Image/Matrix ''' io.imshow(img) plt.title('Original Image') io.show() ''' # Image Histogram ''' hist = exposure.histogram(img) plt.bar(hist[1], hist[0]) plt.title('Histogram') plt.show() ''' # Binarization by Thresholding ret, binary = cv.threshold(img, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU) #ret, binary = cv.threshold(img, 0, 255, cv.THRESH_BINARY | cv.THRESH_TRIANGLE) #print ret th = ret img_binary = (img < th).astype(np.double) img_dilation = morphology.binary_dilation(img_binary, selem=None) img_erosion = morphology.binary_erosion(img_binary, selem=None) # Displaying Binary Image ''' io.imshow(img_binary) plt.title('Binary Image') io.show() ''' # Connected Component Analysis img_label = label(img_binary, background=0) ''' io.imshow(img_label) plt.title('Labeled Image') io.show() print np.amax(img_label) ''' # Displaying Component Bounding Boxes regions = regionprops(img_label) io.imshow(img_binary) ax = plt.gca() thresholdR = 15 thresholdC = 15 for props in regions: minr, minc, maxr, maxc = props.bbox if (maxr - minr) >= thresholdR and (maxc - minc) >= thresholdC: # Computing Hu Moments and Removing Small Components roi = img_binary[minr:maxr, minc:maxc] m = moments(roi) cr = m[0, 1] / m[0, 0] cc = m[1, 0] / m[0, 0] mu = moments_central(roi, cr, cc) nu = moments_normalized(mu) hu = moments_hu(nu) Features.append(hu) featuresLabels.append(name) plt.text(maxc, minr, name, bbox=dict(facecolor='white', alpha=0.5)) ax.add_patch(Rectangle((minc, minr), maxc - minc, maxr - minr, fill=False, edgecolor='red', linewidth=1)) plt.title('Bounding Boxes') #plt.savefig('report/' + name + '.png') io.show() ''' D = cdist(Features, Features) print D io.imshow(D) plt.title('Distance Matrix') io.show() ''' return Features, featuresLabels
def test(): trainFeatures, trainLebels = extractFeatures() trainMeans, trainDeviations = normalization(trainFeatures) testNames = ['test1', 'test2'] #testNames = ['test1'] testFeatures = [] testLabels = [] testTruth = [] correct = 0 D_copy = np.array(0) #textPosition = [] for i in range(len(testNames)): classes, locations = readPkl(testNames[i]) img = io.imread(testNames[i] + '.bmp') #testTruth = ['a']*7+['d']*7+['m']*7+['n']*7+['o']*7+['p']*7+['q']*7+['r']*7+['u']*7+['w']*7 ret, binary = cv.threshold(img, 0, 255, cv.THRESH_BINARY | cv.THRESH_OTSU) #ret, binary = cv.threshold(img, 0, 255, cv.THRESH_BINARY | cv.THRESH_TRIANGLE) #print ret th = ret img_binary = (img < th).astype(np.double) img_dilation = morphology.binary_dilation(img_binary, selem=None) img_erosion = morphology.binary_erosion(img_binary, selem=None) img_label = label(img_binary, background=0) regions = regionprops(img_label) io.imshow(img_binary) ax = plt.gca() thresholdR = 15 thresholdC = 15 for props in regions: minr, minc, maxr, maxc = props.bbox # Computing Hu Moments and Removing Small Components if (maxr - minr) >= thresholdR and (maxc - minc) >= thresholdC: #textPosition.append((maxc, minr)) roi = img_binary[minr:maxr, minc:maxc] m = moments(roi) cr = m[0, 1] / m[0, 0] cc = m[1, 0] / m[0, 0] mu = moments_central(roi, cr, cc) nu = moments_normalized(mu) hu = moments_hu(nu) testFeatures.append(hu) for i in range(7): testFeatures[-1][i] = (testFeatures[-1][i] - trainMeans[i]) / trainDeviations[i] D = cdist(testFeatures, trainFeatures) #D_copy = copy.deepcopy(D) D_index = np.argsort(D, axis=1) testLabels.append(trainLebels[D_index[-1][0]]) indexFix = locationFix(locations, minr, minc, maxr, maxc) if indexFix is not None: if testLabels[-1] == classes[indexFix]: correct += 1 plt.text(maxc, minr, testLabels[-1], bbox=dict(facecolor='white', alpha=0.5)) ax.add_patch(Rectangle((minc, minr), maxc - minc, maxr - minr, fill=False, edgecolor='red', linewidth=1)) plt.title('Bounding Boxes') io.show() print correct, len(testLabels) correctRate = correct / len(testLabels) print correctRate
## %load_ext autoreload %autoreload 2 ## sys.path.append(".") ## from skimage.io import imread, imshow from patchify import patchify, unpatchify ## img = imread("wp2559551.jpg") ## patches = patchify(img, (900, 256, 3), step=1) ## imshow(unpatchify(patches, img.shape)) ## patches = patchify(img[:,:,1], (645, 256), step=1) ## imshow(img[:,:,1]) ## imshow(unpatchify(patches, img[:,:,1].shape)) ##
from skimage import io, data io.imshow(data.camera()) io.show() io.imshow(data.text()) io.show()
cols = image.shape[1] print(rows) print(cols) image = image.reshape(image.shape[0] * image.shape[1], 3) kmeans = KMeans(n_clusters=128, n_init=10, max_iter=200) kmeans.fit(image) print('finish1') clusters = np.asarray(kmeans.cluster_centers_, dtype=np.uint8) labels = np.asarray(kmeans.labels_, dtype=np.uint8) labels = labels.reshape(rows, cols) print('finish2') print(clusters.shape) np.save('codebook_test.npy', clusters) io.imsave('zip_testimg.jpg', labels) print('finish3') image = io.imread('compressed_test.jpg') io.imshow(image) io.show() print('finish4')
img = io.imread('/home/jorge/Documentos/Topicos/subject11.surprised') #lena = misc.imread('img3.JPG') io.imsave("lena.JPG", img) #plt.imshow(img) #plt.show() img = cv2.imread('/home/jorge/Documentos/Topicos/lena.JPG') gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale(gray, 1.3, 5) for (x, y, w, h) in faces: cv2.rectangle(img, (x, y), (x + w, y + h), (0, 0, 255), 2) roi_gray = gray[y:y + h, x:x + w] roi_color = img[y:y + h, x:x + w] eyes = eye_cascade.detectMultiScale(roi_gray) for (ex, ey, ew, eh) in eyes: cv2.rectangle(roi_color, (ex, ey), (ex + ew, ey + eh), (0, 255, 0), 2) io.imsave("lena.JPG", img) #cv2.imshow('img',img2) #cv2.waitKey(0) io.imshow(img) io.show() #plt.imshow(l, cmap=plt.cm.gray) #plt.show()
def Colorizing_the_Russian_Empire_tif(file): img = skio.imread(file) height = img.shape[0] // 3 Three_Channel = Get_three_channel(img) for i in range(len(Three_Channel)): Three_Channel[i] = Crop_Img(Three_Channel[i]) reconstruct_b = Three_Channel[0] reconstruct_g = Three_Channel[1] reconstruct_r = Three_Channel[2] down_scale = 20 k_size = int((height // down_scale) // 5) g_shift_row, g_shift_col, r_shift_row, r_shift_col = 0, 0, 0, 0 while (down_scale >= 1): smaller_b = sktr.downscale_local_mean(Three_Channel[0], (down_scale, down_scale)) smaller_g = sktr.downscale_local_mean(Three_Channel[1], (down_scale, down_scale)) smaller_r = sktr.downscale_local_mean(Three_Channel[2], (down_scale, down_scale)) Shift_result = alignGandRtoB(smaller_r, smaller_g, smaller_b, k_size) Shift_g = Shift_result[0] Shift_r = Shift_result[1] g_shift_row += (Shift_g[0] * down_scale) g_shift_col += (Shift_g[1] * down_scale) r_shift_row += (Shift_r[0] * down_scale) r_shift_col += (Shift_r[1] * down_scale) Three_Channel[1] = np.roll(Three_Channel[1], Shift_g[0] * down_scale, axis=0) Three_Channel[1] = np.roll(Three_Channel[1], Shift_g[1] * down_scale, axis=1) Three_Channel[2] = np.roll(Three_Channel[2], Shift_r[0] * down_scale, axis=0) Three_Channel[2] = np.roll(Three_Channel[2], Shift_r[1] * down_scale, axis=1) down_scale = down_scale // 2 k_size = k_size // 2 reconstruct_g = np.roll(reconstruct_g, g_shift_row, axis=0) reconstruct_g = np.roll(reconstruct_g, g_shift_col, axis=1) reconstruct_r = np.roll(reconstruct_r, r_shift_row, axis=0) reconstruct_r = np.roll(reconstruct_r, r_shift_col, axis=1) output = np.dstack([reconstruct_r, reconstruct_g, reconstruct_b]) fname = 'aftre' + file[-8:-4] + '.jpg' skio.imsave(fname, output) skio.imshow(output) skio.show()
def debugim(im): imm = np.asarray(im) io.imshow(imm) plt.show()
preds_test_flat = preds_test_t # Create list of upsampled test masks, so that the masks match the original image sizes preds_test_upsampled = [] for i in range(len(preds_test)): preds_test_upsampled.append( resize(np.squeeze(preds_test_flat[i]), (sizes_test[i][0], sizes_test[i][1]), mode='constant', preserve_range=True)) #need take the whole mask of the training set and break them down into individual cells #use skimage to find separate cells, may have trouble if they overlap new_test_ids = [] rles = [] for n, id_ in enumerate(test_ids): cx, cy = prob_to_centers(preds_test_upsampled[n]) #rles.extend(rle) #new_test_ids.extend([id_] * len(rle)) if (n < 10): pltImg = resize(X_test[n], (sizes_test[n][0], sizes_test[n][1]), mode='constant', preserve_range=True) plt.subplot(221) imshow(np.squeeze(pltImg)) plt.subplot(222) plt.plot(cy, cx, 'ro') plt.axis([0, sizes_test[n][1], sizes_test[n][0], 0]) plt.subplot(223) imshow(np.squeeze(preds_test_upsampled[n])) plt.show()
get_ipython().magic(u'matplotlib inline') plt.rcParams['figure.figsize'] = (20.0, 10.0) print("opencv version", (cv2.__version__)) # In[2]: import warnings warnings.filterwarnings('ignore') # ## Convert local image to greyscale # In[3]: feather = io.imread("./images/pena_pavao.jpg") io.imshow(feather) io.show() # In[4]: feather = io.imread("./images/pena_pavao.jpg", as_grey=True) print(type(feather), feather.shape, feather.dtype) io.imshow(feather) io.show() # In[5]: image = cv2.imread("./images/pena_pavao.jpg", 0) cv2.imshow('Grayscale', image) #cv2.waitKey(0) dont use this one on jupyter notebook cv2.startWindowThread()
''' 将lena图片进行二值化,像素值大于128的变为1,否则变为0 ''' from skimage import io,data,color img=data.chelsea() # 使用了color模块的rgb2gray()函数,将彩色三通道图片转换成灰度图。转换结果为float64类型的数组,范围为[0,1]之间。 img_gray = color.rgb2gray(img) rows, cols = img_gray.shape for i in range(rows): for j in range(cols): if (img_gray[i, j] <= 0.5): img_gray[i, j] = 0 else: img_gray[i,j] = 1 pass pass io.imshow(img_gray) # 将彩色三通道图片转换成灰度图,最后变成unit8, float转换为unit8是有信息损失的。
def show(img): io.imshow(img) io.show()
] def to_bits(s): result = [] for c in s: bits = bin(ord(c))[2:] result.extend(map(int, bits.rjust(8, '0'))) return result def from_bits(bits): chars = [] for i in range(len(bits) // 8): byte_char = bits[i * 8:(i + 1) * 8] int_char = int(''.join(map(str, byte_char)), 2) chars.append(chr(int_char)) return ''.join(chars) if __name__ == '__main__': original = io.imread('pic.jpeg') test_message = to_bits("Hello") changed = embed_message(original, test_message) mes = retrieve_message(changed, len(test_message)) print(from_bits(mes)) io.imshow(np.hstack((original, changed))) plt.show()
anatPath = '{}\\sub-01_anat_sub-01_T1w.nii'.format(datasetDir) #maskImg = masking.compute_gray_matter_mask(anatPath, threshold=0.8, connected=True, opening=3, verbose=1) #maskImg = masking.compute_background_mask(anatPath, verbose=2) #maskImg = masking.compute_epi_mask(funcPath) #brainImg = image.clean_img(funcPath, high_pass=0.009, standardize=True, t_r=2.5, mask_img=maskImg) #brainImg = image.mean_img(funcPath, verbose=2, n_jobs=-1) #brainImg = image.smooth_img(brainImg, fwhm='fast') #brainImg = image.math_img('img1 * img2', img1=brainImg, img2=maskImg) #brainImg = image.math_img('img1 * img2', img1=anatPath, img2=maskImg) #view = plotting.view_img(stat_map_img=brainImg, bg_img=None, threshold=None) #view.open_in_browser() #brainImg = image.load_img(anatPath) #cutSlices = plotting.find_cut_slices(brainImg, n_cuts=1) #plotting.plot_anat(brainImg, display_mode='z', output_file='{}\\test.png'.format(dataDir), cut_coords=(5,), annotate=False, draw_cross=False) testImg = r'{}\\test.png'.format(dataDir) img = io.imread(testImg) img = color.rgb2gray(img) #img = util.invert(img) #io.imshow(img) #res = morphology.thin(img, 1000) startPos = np.array([ img.shape[0] / 2.0, img.shape[1] / 2.0, img.shape[0] / 3.0, img.shape[1] / 2.0, img.shape[0] * (2.0 / 3.0), img.shape[1] / 2.0 ]) startPos = np.reshape(startPos, (3, 2)) #res = segmentation.active_contour(image=img, snake=startPos) #res = filters.frangi(img, scale_range=(1, 2), scale_step=0.25, beta1=1, beta2=15) res = filters.apply_hysteresis_threshold(img, 0.2, 0.24) io.imshow(res)
def run_sgpmd_demixing(folder): # read in motion corrected movie t1 = time.time() #path = os.path.join(folder, 'sgpmd/output') path = '/home/nel/Code/volpy_test/invivo-imaging/test_data/memory_test/403106_3min_10000/output' noise = np.squeeze(io.imread(path + '/Sn_image.tif')) [nrows, ncols] = noise.shape if os.path.isfile(path + '/motion_corrected.tif'): mov = io.imread(path + '/motion_corrected.tif').transpose(1, 2, 0) elif os.path.isfile(path + '/denoised.tif'): mov = io.imread(path + '/denoised.tif') else: raise ValueError('No valid input file') # read in the mask for blood if os.path.isfile(path + '/bloodmask.tif'): bloodmask = np.squeeze(io.imread(path + '/bloodmask.tif')) mov = mov * np.repeat( np.expand_dims(noise * bloodmask, 2), mov.shape[2], axis=2) else: mov = mov * np.repeat(np.expand_dims(noise, 2), mov.shape[2], axis=2) mov = -mov # display average movie print(mov.shape) #io.imshow(np.std(mov,axis=2)); # ## Spatial 2x2 Binning movB = mov.reshape(int(mov.shape[0] / 2), 2, int(mov.shape[1] / 2), 2, mov.shape[2]) movB = np.mean(np.mean(movB, axis=1), axis=2) movB.shape movB = mov # show standard deviation image of binned movie io.imshow(np.std(movB, axis=2)) # %% Load Manually Initialized Background bg_flag = os.path.isfile(path + '/ff.tif') if bg_flag: # import manually initialized background components ff_ini = io.imread(path + '/ff.tif') fb_ini = io.imread(path + '/fb.tif') # bin the spatial components fb_ini = fb_ini.reshape(mov.shape[1], mov.shape[0], -1).transpose(1, 0, 2) # fb_ini = fb_ini.reshape(int(fb_ini.shape[0]/2),2,int(fb_ini.shape[1]/2),2,fb_ini.shape[2]) # fb_ini = np.mean(np.mean(fb_ini,axis=1),axis=2) fb_ini.shape # plot manually initialized background components plt.figure(figsize=(30, 20)) for i in range(6): plt.subplot(3, 4, 2 * i + 1) plt.plot(ff_ini[:2000, i]) plt.subplot(3, 4, 2 * i + 2) io.imshow(fb_ini[:, :, i]) # %% if bg_flag: # select which background components to use for initialization bkg_components = range(3) fb_ini = fb_ini[:, :, bkg_components].reshape(movB.shape[0] * movB.shape[1], len(bkg_components)) ff_ini = ff_ini[:, bkg_components] # %% Get Cell Spatial Supports from High Pass Filtered Movie start = time.time() # select which window to demix on first_frame = 1 last_frame = 5000 movHP = sup.hp_filt_data(movB, spacing=10) # %% rlt = sup.axon_pipeline_Y( movHP[:, :, first_frame:last_frame], fb_ini=np.zeros(1), ff_ini=np.zeros(1), ##### Superpixel parameters # thresholding level th=[4], # correlation threshold for finding superpixels # (range around 0.8-0.99) cut_off_point=[0.95], # minimum pixel count of a superpixel # don't need to change these unless cell sizes change length_cut=[10], # maximum pixel count of a superpixel # don't need to change these unless cell sizes change length_max=[200], patch_size=[30, 30], # correlation threshold between superpixels for merging # likely don't need to change this residual_cut=[np.sqrt(1 - (0.8)**2)], pass_num=1, bg=False, ##### Cell-finding, NMF parameters # correlation threshold of pixel with superpixel trace to include pixel in cell # (range 0.3-0.6) corr_th_fix=0.4, # correlation threshold for merging two cells # (default 0.8, but likely don't need to change) merge_corr_thr=0.8, ##### Other options # if True, only superpixel analysis run; if False, NMF is also run to find cells sup_only=False, # the number of superpixels to remove (starting from the dimmest) remove=0) print("Demixing took: " + str(time.time() - start) + " sec") #%% plot pure superpixels num_pass = len(rlt["superpixel_rlt"]) scale = np.maximum(1, (rlt["superpixel_rlt"][0]["connect_mat_1"].shape[1] / rlt["superpixel_rlt"][0]["connect_mat_1"].shape[0])) fig = plt.figure(figsize=(4 * scale * num_pass, 4)) plt.subplot(1, num_pass + 2, 1) io.imshow(np.std(movB, axis=2)) for p in range(num_pass): connect_mat_1 = rlt["superpixel_rlt"][p]["connect_mat_1"] pure_pix = rlt["superpixel_rlt"][p]["pure_pix"] brightness_rank = rlt["superpixel_rlt"][p]["brightness_rank"] ax1 = plt.subplot(1, num_pass + 2, p + 2) dims = connect_mat_1.shape connect_mat_1_pure = connect_mat_1.copy() connect_mat_1_pure = connect_mat_1_pure.reshape(np.prod(dims), order="F") connect_mat_1_pure[~np.in1d(connect_mat_1_pure, pure_pix)] = 0 connect_mat_1_pure = connect_mat_1_pure.reshape(dims, order="F") ax1.imshow(connect_mat_1_pure, cmap="nipy_spectral_r") for ii in range(len(pure_pix)): pos = np.where(connect_mat_1_pure[:, :] == pure_pix[ii]) pos0 = pos[0] pos1 = pos[1] ax1.text((pos1)[np.array(len(pos1) / 3, dtype=int)], (pos0)[np.array(len(pos0) / 3, dtype=int)], f"{brightness_rank[ii]+1}", verticalalignment='bottom', horizontalalignment='right', color='black', fontsize=15) #, fontweight="bold") ax1.set(title="pass " + str(p + 1)) ax1.title.set_fontsize(15) ax1.title.set_fontweight("bold") plt.tight_layout() # %%plot all cell traces and footprints from NMF cell_ct = rlt["fin_rlt"]["c"].shape[1] plt.figure(figsize=(25, 3 * cell_ct)) ref_im = np.std(movB, axis=2).transpose(1, 0) for cell_num in range(cell_ct): plt.subplot(cell_ct, 2, 2 * cell_num + 1) plt.plot(rlt["fin_rlt"]["c"][:, cell_num]) plt.title(cell_num) plt.subplot(cell_ct, 2, 2 * cell_num + 2) lower, upper = np.percentile(ref_im.flatten(), [1, 99]) plt.imshow(ref_im, cmap='gray', interpolation='none', clim=[lower, upper]) cell_loc = rlt["fin_rlt"]["a"][:, cell_num].reshape( movB.shape[1], movB.shape[0]) #.transpose(1,0) cell_loc = np.ma.masked_where(cell_loc == 0, cell_loc) plt.imshow(cell_loc, cmap='jet', alpha=0.5) # %% Get Background Components from Unfiltered Movie # rank of background to model, if none selected bg_rank = 3 final_cells = list(range(cell_ct)) nCells = len(final_cells) a = rlt["fin_rlt"]["a"][:, final_cells].copy() c = rlt["fin_rlt"]["c"][:, final_cells].copy() b = rlt["fin_rlt"]["b"].copy() suffix = '' io.imsave(path + '/nmf_traces' + suffix + '.tif', c) #%% dims = movB.shape[:2] T = last_frame - first_frame movVec = movB.reshape(np.prod(dims), -1, order="F") mov_min = movVec.min() if mov_min < 0: mov_min_pw = movVec.min(axis=1, keepdims=True) movVec -= mov_min_pw normalize_factor = np.std(movVec, axis=1, keepdims=True) * T #%% if bg_flag: fb = fb_ini ff = ff_ini[first_frame:last_frame, :] bg_rank = fb.shape[1] else: bg_comp_pos = np.where(a.sum(axis=1) == 0)[0] y_temp = movVec[bg_comp_pos, first_frame:last_frame] fb = np.zeros([movVec.shape[0], bg_rank]) y_temp = y_temp - y_temp.mean(axis=1, keepdims=True) svd = TruncatedSVD(n_components=bg_rank, n_iter=7, random_state=0) fb[bg_comp_pos, :] = svd.fit_transform(y_temp) ff = svd.components_.T ff = ff - ff.mean(axis=0, keepdims=True) a, c, b, fb, ff, res, corr_img_all_r, num_list = sup.update_AC_bg_l2_Y( movVec[:, first_frame:last_frame].copy(), normalize_factor, a, c, b, ff, fb, dims, corr_th_fix=0.35, maxiter=35, tol=1e-8, merge_corr_thr=0.8, merge_overlap_thr=0.8, keep_shape=True) #%% plot all cell traces and footprints cell_ct = c.shape[1] plt.figure(figsize=(25, 3 * cell_ct)) ref_im = np.std(movB, axis=2).transpose(1, 0) for cell_num in range(cell_ct): plt.subplot(cell_ct, 2, 2 * cell_num + 1) plt.plot(c[:, cell_num]) plt.title(cell_num) plt.subplot(cell_ct, 2, 2 * cell_num + 2) lower, upper = np.percentile(ref_im.flatten(), [1, 99]) plt.imshow(ref_im, cmap='gray', interpolation='none', clim=[lower, upper]) cell_loc = a[:, cell_num].reshape(movB.shape[1], movB.shape[0]) #.transpose(1,0) cell_loc = np.ma.masked_where(cell_loc == 0, cell_loc) plt.imshow(cell_loc, cmap='jet', alpha=0.5) plt.colorbar() # %% plot all background traces and footprints bg_rank = fb.shape[1] plt.figure(figsize=(25, 3 * bg_rank)) for bkgd_num in range(bg_rank): plt.subplot(bg_rank, 2, 2 * bkgd_num + 1) plt.plot(ff[:, bkgd_num]) bkgd_comp = fb[:, bkgd_num].reshape(movB.shape[1::-1]) #.transpose(1,0) plt.subplot(bg_rank, 2, 2 * bkgd_num + 2) plt.imshow(bkgd_comp) plt.colorbar() def tv_norm(image): return np.sum(np.abs(image[:, :-1] - image[:, 1:])) + np.sum( np.abs(image[:-1, :] - image[1:, :])) Y = movB.transpose(1, 0, 2).reshape(movB.shape[0] * movB.shape[1], movB.shape[2]) X = np.hstack((a, fb)) X = X / np.ptp(X, axis=0) X2 = np.zeros((X.shape[0], nCells + bg_rank)) X2[:, :nCells] = X[:, :nCells] plt.figure(figsize=(25, 3 * bg_rank)) plt.title('New Background Components') lr = 0.001 maxIters = 1000 for b in range(bg_rank): bg_im = X[:, -(b + 1)].reshape(movB.shape[-2::-1]) plt.subplot(bg_rank, 2, (bg_rank - b) * 2 - 1) plt.imshow(bg_im) plt.title(str(tv_norm(bg_im))) plt.colorbar() weights = torch.zeros((nCells, 1), requires_grad=True, dtype=torch.double) image = torch.from_numpy(bg_im) for idx in range(maxIters): test_im = image - torch.reshape( torch.from_numpy(X[:, :nCells]) @ weights, movB.shape[-2::-1]) tv = torch.sum( torch.abs(test_im[:, :-1] - test_im[:, 1:])) + torch.sum( torch.abs(test_im[:-1, :] - test_im[1:, :])) tv.backward() with torch.no_grad(): weights -= lr * weights.grad weights.grad.zero_() opt_weights = weights.data.numpy() X2[:, -(b + 1)] = np.maximum( X[:, -(b + 1)] - np.squeeze(X[:, :nCells] @ opt_weights), 0) plt.subplot(bg_rank, 2, (bg_rank - b) * 2) plt.imshow(X2[:, -(b + 1)].reshape(movB.shape[-2::-1]), vmin=0, vmax=1) plt.title(str(tv_norm(X2[:, -(b + 1)].reshape(movB.shape[-2::-1]).T))) plt.colorbar() # %% Get Final Traces beta_hat2 = np.linalg.lstsq(X2, Y)[0] res = np.mean(np.square(Y - X2 @ beta_hat2), axis=0) # %% Visualizations num_traces = beta_hat2.shape[0] plt.figure(figsize=(25, 3 * num_traces)) ref_im = np.std(movB, axis=2).transpose(1, 0) for idx in range(num_traces): plt.subplot(num_traces, 2, 2 * idx + 1) plt.plot(beta_hat2[idx, :]) plt.subplot(num_traces, 2, 2 * idx + 2) lower, upper = np.percentile(ref_im.flatten(), [1, 99]) plt.imshow(ref_im, cmap='gray', interpolation='none', clim=[lower, upper]) cell_loc = X2[:, idx].reshape(movB.shape[1::-1]) #.transpose(1,0) cell_loc = np.ma.masked_where(abs(cell_loc) < 1e-8, cell_loc) plt.imshow(cell_loc, cmap='jet', alpha=0.5) # %% Save Results t2 = time.time() suffix = '' io.imsave(path + '/spatial_footprints' + suffix + '.tif', X2) io.imsave(path + '/cell_spatial_footprints' + suffix + '.tif', X2[:, :nCells]) io.imsave(path + '/temporal_traces' + suffix + '.tif', beta_hat2) io.imsave(path + '/cell_traces' + suffix + '.tif', beta_hat2[:nCells, :]) io.imsave(path + '/residual_var' + suffix + '.tif', res) cell_locations = center_of_mass(X2[:, 0].reshape(movB.shape[1::-1]).transpose( 1, 0)) for idx in range(nCells - 1): cell_locations = np.vstack((cell_locations, center_of_mass(X2[:, idx + 1].reshape( movB.shape[1::-1]).transpose(1, 0)))) io.imsave(path + '/cell_locations' + suffix + '.tif', np.array(cell_locations)) if nCells > 1: io.imsave( path + '/cell_demixing_matrix' + suffix + '.tif', np.linalg.inv(np.array(X2[:, :nCells].T @ X2[:, :nCells])) @ X2[:, :nCells].T) print('Saved!')
preds_val_t = (preds_val > 0.5).astype(np.uint8) preds_test_t = (preds_test > 0.5).astype(np.uint8) # Create list of upsampled test masks preds_test_upsampled = [] for i in range(len(preds_test)): preds_test_upsampled.append( resize(np.squeeze(preds_test[i]), (sizes_test[i][0], sizes_test[i][1]), mode='constant', preserve_range=True)) # In[ ]: # Perform a sanity check on some random training samples ix = random.randint(0, len(preds_train_t)) imshow(X_train[ix]) plt.show() imshow(np.squeeze(Y_train[ix])) plt.show() imshow(np.squeeze(preds_train_t[ix])) plt.show() # In[ ]: # Perform a sanity check on some random validation samples ix = random.randint(0, len(preds_val_t)) imshow(X_train[int(X_train.shape[0] * 0.9):][ix]) plt.show() imshow(np.squeeze(Y_train[int(Y_train.shape[0] * 0.9):][ix])) plt.show() imshow(np.squeeze(preds_val_t[ix]))
# %% import numpy as np from skimage import io img = io.imread('flowers.jpg') io.imshow(img) # %% img[250][1500] # %% for i in range(500): for j in range(1000): img[i][j][0] = 51 img[i][j][1] = 0 img[i][j][2] = 255 for k in range(1000, 2000): img[i][k][0] = 204 img[i][k][1] = 255 img[i][k][2] = 51 for l in range(2000, 3000): img[i][l][0] = 255 img[i][l][1] = 255 img[i][l][2] = 255 io.imshow(img) # %% img = io.imread('flowers.jpg') io.imshow(img)
#all of the align functions call cm.multi_iteration_offset, which in turn calls cm.find_offset_by_subtraction ag = cm.align(g, b) ar = cm.align(r, b) #uncomment to use edges for alignment (Canny) # ag = cm.align_edges(g, b) # ar = cm.align_edges(r, b) #uncomment to use gradient for alignment (Sobel) # ag = cm.align_gradient(g, b) # ar = cm.align_gradient(r, b) #create color image img_out = np.dstack([ar, ag, b]) img_orig = np.dstack([r, g, b]) img_out = cm.remove_border(img_out, 0.07, 10, 4) img_out = cm.image_correct(img_out) #uncomment to view original image # skio.imshow(img_orig) # skio.show() skio.imshow(img_out) skio.show() #uncomment to save image # name = os.path.basename(name) # name = os.path.splitext(name)[0] # skio.imsave("out_" + name + ".jpg", img_out)
img = imread(path + '/images/' + id_ + '.png')[:,:,:IMG_CHANNELS] img = resize(img, (IMG_HEIGHT, IMG_WIDTH), mode='constant', preserve_range=True) X_train[n] = img mask = np.zeros((IMG_HEIGHT, IMG_WIDTH, 1), dtype=np.bool) for mask_file in next(os.walk(path + '/masks/'))[2]: mask_ = imread(path + '/masks/' + mask_file) mask_ = np.expand_dims(resize(mask_, (IMG_HEIGHT, IMG_WIDTH), mode='constant', preserve_range=True), axis=-1) mask = np.maximum(mask, mask_) Y_train[n] = mask """Check if the image is resized and is viewable (both mask and image for training)""" #Check if they are parsed right ix = np.random.randint(0, len(train_ids)) imshow(X_train[ix]) plt.show() imshow(np.squeeze(Y_train[ix])) plt.show() """# Trying UNet""" from sklearn.model_selection import train_test_split, GridSearchCV from sklearn.preprocessing import StandardScaler from sklearn.pipeline import Pipeline from keras.models import Sequential, Model from keras.wrappers.scikit_learn import KerasClassifier from keras.layers import Input, concatenate, Conv2D, MaxPool2D, UpSampling2D, Dropout, Cropping2D from keras.utils import to_categorical from keras.layers.core import Dropout, Lambda
#sobel_gradient_threshold=0.05 #size threshold=100 shape = np.shape(image) image1 = preprocessing_for_icefinder(image) image2 = minimum_filter(image1, 4, mode='reflect') sobel1 = sobel(image2) image3 = sobel1 > sobel_gradient_threshold image4 = binary_fill_holes(mh.morph.dilate(image3)) #label and clear the image labeled, n_nucleus = mh.label(image4) sizes = mh.labeled.labeled_size(labeled) too_small = np.where(sizes < size_threshold) labeled = mh.labeled.remove_regions(labeled, too_small) relabeled, n_left = mh.labeled.relabel(labeled) if n_left > 20: print("can not locate ice in the image") else: image5 = relabeled > 0 #make the binary image image6 = resize(image5, shape, order=2, mode='symmetric', preserve_range=True) return image6 img = mrcfile.open('ice11.mrc').data img2 = find_ice(img, 0.05, 100) imshow(img2) show()