def setUp(self): self.stage = pos.StagePosition(x=0) self.stage2 = pos.StagePosition(x=3, y=4, z=0) self.stage3 = pos.StagePosition(x=0, y=0, z=0) self.stage4 = pos.StagePosition(x=100, y=30, z=15) self.stage5 = pos.StagePosition(x=0, y=0, z=0) self.stagelist = [self.stage, self.stage2, self.stage3, self.stage4] self.stagelist2 = [self.stage2, self.stage] print (self.stage) print (self.stage2) print (self.stage3) print (self.stage4)
def get_center(mmc, center, frame_to_pixel_ratio, camera_pixel_width, camera_pixel_height): cur_position = pos.current(mmc) x_change = (center[0] - (float(camera_pixel_width) / 2)) * frame_to_pixel_ratio y_change = (center[1] - (float(camera_pixel_height) / 2)) * frame_to_pixel_ratio new_x = cur_position.x - x_change new_y = cur_position.y - y_change return pos.StagePosition(x=new_x, y=new_y)
def get_position_list(self, focused_pl): ''' Calculates the position list for imaging args: focused_pl: The position list of the focused interior points. returns: PositionList() ''' # get the focus model from the focused points focus_func = focus.predict_z_height(focused_pl) x_steps = int( np.ceil(self.chip['number_of_streets'] / self.number_of_apartments_in_frame_x)) y_steps = int( np.ceil(self.chip['number_of_apartments'] / self.number_of_apartments_in_frame_y)) x_step_size = self.number_of_apartments_in_frame_x * self.chip[ 'street_spacing'] y_step_size = self.number_of_apartments_in_frame_y * self.chip[ 'apartment_spacing'] # Get 2D rotation matix for origin point origin = np.matmul(np.linalg.inv( self.R), [self.corner_poslist[0].x, self.corner_poslist[0].y]) poslist = pos.PositionList() x_list = range(x_steps) for y_ctr in range(y_steps): for x_ctr in x_list: rotation = origin + [ self.first_position[0] + x_step_size * x_ctr, self.first_position[1] - y_step_size * y_ctr ] posit = np.matmul(self.R, rotation) name = ("_ST_" + str( x_ctr * self.number_of_apartments_in_frame_x).zfill(3) + "_APT_" + str(y_ctr * self.number_of_apartments_in_frame_y).zfill(3) + "_") s = pos.StagePosition(x=posit[0], y=posit[1], z=focus_func(posit[0], posit[1])[0], name=name) poslist.append(s) # Each time though reverse the order to snake through chip x_list = x_list[::-1] return poslist
def focus_from_image_stack(xy_points, mmc, delta_z=5, total_z=150, exposure=1): ''' Brute force focus algorthim args: xy_points: a PositionList() of the locations to focus at mmc: Micromanger instance delta_z: distacne between images (um) total_z: total imaging distance (all focused points on chip should be in this range) returns: focused PositionList() ''' # Get focus model focus_model = miq.get_classifier() pos_list = pos.PositionList() # make z position array cur_pos = pos.current(mmc) z = get_z_list(cur_pos.z, delta_z, total_z) cam = sc_utils.start_cam() for posit in xy_points: # Go to the x,y position pos.set_pos(mmc, x=posit.x, y=posit.y) preds = [] for curr_z in z: mmc.setPosition(curr_z) mmc.waitForSystem() frame = cam.get_frame(exp_time=exposure).reshape(cam.sensor_size[::-1]) preds.append(focus_model.score(sc_utils.bytescale(frame, high=65535))) # find the index of the min focus prediction best_focus_index = np.argmin(preds) # append to the PositionList sp = pos.StagePosition(x=posit.x, y=posit.y, z=z[best_focus_index]) pos_list.append(sp) sc_utils.close_cam(cam) return pos_list
def get_focus_position_list(self, fp_x, fp_y): ''' Gets the xy stage positions for the interior focus points args: fp_x: number of focus points in the x direction fp_y: number of focus points in the y direction returns: PositionList() ''' print("--------------") print(self.first_position[0]) print(self.first_position[1]) delta_x = (self.total_x - np.abs(self.first_position[0]) * 2) / (fp_x - 1) delta_y = (self.total_y - np.abs(self.first_position[1]) * 2) / (fp_y - 1) origin = np.matmul(np.linalg.inv( self.R), [self.corner_poslist[0].x, self.corner_poslist[0].y]) print(delta_x) print(delta_y) fp_positions = pos.PositionList() fp_x_list = range(fp_x) for y_ctr in range(fp_y): for x_ctr in fp_x_list: rotation = origin + [ self.first_position[0] + delta_x * x_ctr, (self.first_position[1] - delta_y * y_ctr) ] fp = np.matmul(self.R, rotation) s = pos.StagePosition(x=fp[0], y=fp[1]) fp_positions.append(s) fp_x_list = fp_x_list[::-1] return fp_positions
def focus_from_last_point(xy_points, mmc, model_path, delta_z=10, total_z=150, next_point_range=35, exposure=1): ''' Gets a focused position list using a brute force method to find the first focus point, then after that, used the last focused point as the center of the new, shorter focus range. args: xy_points: a PositionList() of the locations to focus at mmc: Micromanger instance delta_z: distacne between images (um) total_z: total imaging distance (all focused points on chip should be in this range) nex_point_range: range to look (um) for point other than the first point returns: focused PositionList() ''' focus_model = miq.get_classifier(model_path) pos_list = pos.PositionList() # Focus the first point pos.set_pos(mmc, x=xy_points[0].x, y=xy_points[0].y) last_z = focus_point(mmc, focus_model, delta_z=delta_z, total_z=total_z, exposure=exposure) sp = pos.StagePosition(x=xy_points[0].x, y=xy_points[0].y, z=last_z) pos_list.append(sp) z_range = np.arange(-next_point_range/2, next_point_range/2, delta_z) cam = sc_utils.start_cam() for i, posit in enumerate(xy_points): # We already did the first point if i == 0: best_focus_index = 0 continue preds = [] # Go to the next x,y position with the previous best focus pos.set_pos(mmc, x=posit.x, y=posit.y, z=last_z) if best_focus_index > (len(z_range) / 2): # Reverse the order of the list z_range = z_range[::-1] # Build list from last position # in order that makes sense z_list = [(last_z+i) for i in z_range] for j, curr_z in enumerate(z_list): pos.set_pos(mmc, z=curr_z) frame = sc_utils.get_live_frame(cam, exposure) preds.append(focus_model.score(sc_utils.bytescale(frame, high=65535))) if j > 1: if ((preds[j] > preds[j-1]) and (preds[j] > preds[j-2]) and (np.abs(preds[j] - preds[j-1]) > 2 or np.abs(preds[j] - preds[j-2]) > 2)): # Focus got worse break # find the index of the min focus prediction best_focus_index = np.argmin(preds) # append to the PositionList last_z = z_list[best_focus_index] sp = pos.StagePosition(x=posit.x, y=posit.y, z=last_z) pos_list.append(sp) if len(preds) < len(z_list): sc_utils.print_info ('('+ str(posit.x) + ',' + str(posit.y) + ') - Score: ' + str(np.min(preds)) + ' - Good focus') elif preds[best_focus_index] > 5: sc_utils.print_info ('('+ str(posit.x) + ',' + str(posit.y) + ') - Score: ' + str(np.min(preds)) + ' - BAD FOCUS') else: sc_utils.print_info ('('+ str(posit.x) + ',' + str(posit.y) + ') - Score: ' + str(np.min(preds)) + ' - OK focus') sc_utils.close_cam(cam) return pos_list
def auto_image_chip(cur_chip, mmc, save_dir, chip_number, alignment_model_path, focus_model_path, naming_scheme, focus_delta_z, focus_total_z, focus_next_point_range, number_of_focus_points_x, number_of_focus_points_y, focus_exposure, image_rotation, frame_to_pixel_ratio, camera_pixels, exposure, first_position, number_of_apartments_in_frame_x, number_of_apartments_in_frame_y, output_pixels): ''' Aligns, focuses, and images given chip args: chip: an instance of a Chip class (found in chip.py) mmc: Micro-Manager instance (can get from sc_utils.get_stage_controller()) save_dir: directory to save images to chip_number: string to identify chip alignment_model_name: name of the trained model for alignment alignment_model_path: path to the trained model for alignment naming_scheme: Beginning of image file names focus_delta_z: amount to change in the z direction between getting focus prediction focus_total_z: total z in each direction to look for an individual focus point or the first focus point in a set focus_next_point_range: total z in each direction to look for each focus point that directly follows a nearby point that we have already focused (this will need to be increased for chips that are not relatively flat) number_of_focus_points_x: Number of positions to focus at in the x direction (must be greater than 3 for interpolation to work propertly) number_of_focus_points_y: Number of positions to focus at in the y direction (must be greater than 3 for interpolation to work propertly) save_jpg: Saves images as both tiff files and jpg files if True ''' start = time.time() sc_utils.print_info("Starting: Alignment, Focus, and Imaging") model = alignment.get_inference_model(alignment_model_path) p1 = pos.current(mmc) p2 = pos.StagePosition(x=p1.x + cur_chip['chip_width'], y=p1.y) p3 = pos.StagePosition(x=p1.x + cur_chip['chip_width'], y=p1.y - cur_chip['chip_height']) # Create a temporay chip for focusing temp_corners = pos.PositionList(positions=[p1, p2, p3]) print('Corners: ', str(temp_corners)) temp_chip = chip.Chip(temp_corners, first_position, cur_chip, number_of_apartments_in_frame_x, number_of_apartments_in_frame_y) focus_pl = temp_chip.get_focus_position_list(number_of_focus_points_x, number_of_focus_points_y) print('Focus PL: ', str(focus_pl)) # return focused_pl = focus.focus_from_last_point( focus_pl, mmc, focus_model_path, delta_z=focus_delta_z, total_z=focus_total_z, next_point_range=focus_next_point_range, exposure=focus_exposure) focused_pl.save('focused_pl', save_dir) p1.z = focus.predict_z_height(focused_pl, xy_location=(p1.x, p1.y))[0][0] p2.z = focus.predict_z_height(focused_pl, xy_location=(p2.x, p2.y))[0][0] p3.z = focus.predict_z_height(focused_pl, xy_location=(p3.x, p3.y))[0][0] print(p1) p1 = alignment.search_and_find_center(mmc, p1, model, exposure, frame_to_pixel_ratio, camera_pixels[0], camera_pixels[1]) p2 = alignment.search_and_find_center(mmc, p2, model, exposure, frame_to_pixel_ratio, camera_pixels[0], camera_pixels[1]) p3 = alignment.search_and_find_center(mmc, p3, model, exposure, frame_to_pixel_ratio, camera_pixels[0], camera_pixels[1]) align_time = time.time() sc_utils.print_info('Time for alignment:' + str(align_time - start)) # Create a Position List of the corners and save it corners = pos.PositionList(positions=[p1, p2, p3]) corners.save('corners_pl', save_dir) # # Create a chip instance imaging_chip = chip.Chip(corners, first_position, cur_chip, number_of_apartments_in_frame_x, number_of_apartments_in_frame_y) imaging_pl = imaging_chip.get_position_list(focused_pl) imaging_pl.image(mmc, save_dir, naming_scheme, rotation=image_rotation, exposure=exposure, output_pixels=output_pixels) end = time.time() sc_utils.print_info('Total time:' + str(end - start))