def test_nonzero_minimum_box(): test = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 2, 0], [0, 2, 2, 3, 0], [0, 3, 3, 4, 0], [0, 0, 0, 0, 0] ])) reference = cle.push(np.asarray([ [0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 2, 2, 2, 0], [0, 0, 0, 0, 0] ])) result = cle.create(test) flag = cle.create((1, 1, 1)) # as nonzero filters don't touch zero values, we need to initialize the result in advance cle.set(result, 0); cle.nonzero_minimum_box(test, flag, result) print(result) a = cle.pull(result) b = cle.pull(reference) assert (np.allclose(a, b, atol=0.00001))
def test_write_values_to_positions_2d(): positions_and_values = cle.push(np.asarray([ [0, 0, 2, 3, 5], [0, 1, 3, 2, 6], [8, 7, 6, 5, 4] ])) reference = cle.push(np.asarray([ [8, 0, 0, 0, 0, 0], [7, 0, 0, 0, 0, 0], [0, 0, 0, 5, 0, 0], [0, 0, 6, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 4] ])) result = cle.create_like(reference) cle.set(result, 0) result = cle.write_values_to_positions(positions_and_values, result) a = cle.pull(result) b = cle.pull(reference) print(a) print(b) assert (np.array_equal(a, b))
def draw_positions(self, new_positions, value): """bring position lists in the right format and draw the list of coordinates in a given color on the playground. """ positions = cle.push(np.asarray(new_positions)) values_and_positions = cle.create( [positions.shape[0] + 1, positions.shape[1]]) cle.set(values_and_positions, value) cle.paste(positions, values_and_positions, 0, 0) cle.write_values_to_positions(values_and_positions, self.temp)
def test_maximum_sphere_2(): gpu_a = cle.push(np.asarray([[1, 1, 1], [1, 2, 1], [1, 1, 1]])) gpu_b = cle.create(gpu_a) cle.maximum_sphere(gpu_a, gpu_b, 1, 1, 1) a = cle.pull(gpu_b) assert np.min(a) == 1 assert np.max(a) == 2 cle.set(gpu_a, 5) assert np.all(cle.pull(gpu_a) == 5)
def test_copy_slice_to_3d(): test1 = cle.push(np.asarray([[3, 4], [4, 5]])) test2 = cle.create((2, 2, 2)) cle.set(test2, 0) cle.copy_slice(test1, test2, 0) print(test2) a = cle.pull(test2) assert (np.min(a) == 0) assert (np.max(a) == 5) assert (np.mean(a) == 2)
def test_set(): result = cle.create((5, 5)) reference = cle.push( np.asarray([[3, 3, 3, 3, 3], [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], [3, 3, 3, 3, 3], [3, 3, 3, 3, 3]])) cle.set(result, 3) print(result) a = cle.pull(result) b = cle.pull(reference) assert (np.allclose(a, b, 0.001))
def test_draw_line(): reference = cle.push_zyx( np.asarray([[2, 2, 0, 0, 0], [2, 2, 2, 0, 0], [0, 2, 2, 2, 0], [0, 0, 2, 2, 2], [0, 0, 0, 2, 2]])) result = cle.create((5, 5)) cle.set(result, 0) cle.draw_line(result, 1, 1, 0, 4, 4, 0, 1, 2) print(result) a = cle.pull(result) b = cle.pull(reference) assert (np.array_equal(a, b))
def test_draw_box(): reference = cle.push( np.asarray([[0, 0, 0, 0, 0], [0, 2, 2, 2, 0], [0, 2, 2, 2, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]])) result = cle.create((5, 5)) cle.set(result, 0) cle.draw_box(result, 1, 1, 0, 2, 1, 1, 2) print(result) a = cle.pull(result) b = cle.pull(reference) assert (np.array_equal(a, b))
def test_maximum_sphere_1(): test = cle.push(np.asarray([ [1, 1, 1], [1, 2, 1], [1, 1, 1] ])) test2 = cle.create(test) cle.maximum_sphere(test, test2, 1, 1, 1) a = cle.pull(test2) assert (np.min(a) == 1) assert (np.max(a) == 2) cle.set(test, 5) # print(test) # print(cle.pull(test)) a = cle.pull(test) assert (np.min(a) == 5) assert (np.max(a) == 5) assert (np.mean(a) == 5)
def test_touch_matrix_to_mesh(): gpu_touch_matrix = cle.push(np.asarray([[0, 0, 0], [0, 0, 0], [0, 1, 0]])) gpu_point_list = cle.push(np.asarray([[1, 4], [2, 5]])) gpu_output = cle.create([5, 5]) cle.set(gpu_output, 0) gpu_reference = cle.push( np.asarray([[0, 0, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1], [0, 0, 0, 0, 0]]).T) cle.touch_matrix_to_mesh(gpu_point_list, gpu_touch_matrix, gpu_output) a = cle.pull(gpu_output) b = cle.pull(gpu_reference) print(a) print(b) assert (np.array_equal(a, b))
def game_step(self): """Forwards the game by one step and computes the new playground Returns ------- an image with the current state of the game """ # read camera image _, picture = self._video_source.read() # push to GPU and bring in right format current_image = self._push_and_format(picture) # determine difference = cle.sum_z_projection( cle.squared_difference(current_image, self._image_at_beginning)) crop_left = cle.crop(difference, start_x=0, start_y=0, width=self.sensitive_area_width, height=self.height) crop_right = cle.crop(difference, start_x=self.width - self.sensitive_area_width, start_y=0, width=self.sensitive_area_width, height=self.height) # check player positions self.player1_position = self._determine_player_position( self.player1_position, crop_left) self.player2_position = self._determine_player_position( self.player2_position, crop_right) squared_difference_picture = cle.pull(difference) # move puck self.puck_x = self.puck_x + self.puck_delta_x self.puck_y = self.puck_y + self.puck_delta_y # check puck_position if self.puck_y < 0 or self.puck_y > self.height: self.puck_delta_y = -self.puck_delta_y self.puck_y = self.puck_y + self.puck_delta_y # puck at player 1 if self.puck_x <= self.player1_x: self.puck_delta_x = -self.puck_delta_x self.puck_x = self.puck_x + self.puck_delta_x if abs(self.puck_y - self.player1_position) > self.bar_radius: # player 2 scores self.player2_score = self.player2_score + 1 self._level_up() else: self.puck_delta_y = ( self.puck_y - self.player1_position) / self.bar_radius * 5 # puck at player 2 if self.puck_x >= self.player2_x: self.puck_delta_x = -self.puck_delta_x self.puck_x = self.puck_x + self.puck_delta_x if abs(self.puck_y - self.player2_position) > self.bar_radius: # player 1 scores self.player1_score = self.player1_score + 1 self._level_up() else: self.puck_delta_y = ( self.puck_y - self.player2_position) / self.bar_radius * 5 # show game status self.result_label.setText( str(self.player1_score) + ":" + str(self.player2_score)) # draw playground cle.set(self.playground, 0.1) # draw player 1 cle.draw_box(self.playground, self.player1_x, self.player1_position - self.bar_radius, 0, 3, self.bar_radius * 2, 0) # draw player 2 cle.draw_box(self.playground, self.player2_x, self.player2_position - self.bar_radius, 0, 3, self.bar_radius * 2, 0) # draw puck cle.draw_sphere(self.playground, self.puck_x - self.puck_width / 2, self.puck_y - self.puck_height / 2, 0, self.puck_width, self.puck_height, 1) # binary playground image game_state = cle.pull(self.playground) # turn camera view in single channel grey-value image grey = cle.mean_z_projection(current_image) # warp the image gradient_radius = 25 position_delta = 25000 blurred_playground = cle.gaussian_blur(self.playground, sigma_x=gradient_radius, sigma_y=gradient_radius) gradient = cle.laplace_box(blurred_playground) vector_x = cle.multiply_image_and_scalar(gradient, scalar=position_delta) vector_y = cle.multiply_image_and_scalar(gradient, scalar=position_delta) warped_playground = cle.apply_vector_field(grey, vector_x, vector_y) return [ # images to add in napari [ cle.pull(grey), squared_difference_picture, game_state, cle.pull(vector_x), cle.pull(vector_x), cle.pull(warped_playground) ], # names [ 'camera input', 'squared difference', 'game state', 'vector x', 'vector y', 'warped view' ], # visibility [False, False, False, False, False, True] ]
def game_loop(self): """ This function is called at every game iteration. It checks if bullets hit nuclei and redraws the playground """ bullet_radius = 5 # empty playground cle.set(self.playground, 0) # pull nuclei from GPU so that we can access individual pixels nuclei = np.asarray(self.nuclei) # prepare all existing labels in a list. We set them to 0 in case a nucleus was hit labels_to_keep = list(range(0, int(np.max(self.nuclei) + 1))) # future bullets to keep new_bullets = [] for bullet in self.bullets: bullet[1] += 10 # check if a bullet has hit a nucleus try: label = nuclei[int(self.playground.shape[0] - bullet[1]), int(bullet[0] + self.fov_x)] except IndexError: label = 0 if label != 0: # bullet has hit a nucleus labels_to_keep[label] = 0 elif bullet[1] > self.playground.shape[1]: pass # bullet has left the playground else: new_bullets.append(bullet) # draw bullets cle.draw_sphere(self.playground, bullet[0], self.playground.shape[0] - bullet[1], 0, bullet_radius, bullet_radius, 1, 1) self.bullets = new_bullets # only keep cells where the nuclei weren't hit new_label_ids = np.asarray(labels_to_keep) cle.replace_intensities(self.nuclei, new_label_ids, self.nuclei) cle.replace_intensities(self.cells, new_label_ids, self.cells) # make a binary image of areas to keep binary = self.cells > 0 # draw player cle.draw_box(self.playground, self.player_position - 5, self.playground.shape[0] - 20, 0, 10, 20, 1, 2) cle.draw_box(self.playground, self.player_position - 15, self.playground.shape[0] - 10, 0, 30, 10, 1, 2) # collect all layers in a dictionary result = {} for i, image in enumerate(self.images): result["channel" + str(i)] = self.crop_fov( cle.multiply_images(image, binary)) # add segmentation (invisble) and playground result['nuclei'] = self.crop_fov(self.nuclei, self.fov_nuclei) result['cells'] = self.crop_fov(self.cells, self.fov_cells) result['playground'] = cle.copy(self.playground) self.fov_x += self.fov_delta_x if self.fov_x <= 0: self.fov_x = 0 self.fov_delta_x = 1 elif self.fov_x >= self.fov_max_x: self.fov_x = self.fov_max_x self.fov_delta_x = -1 return result
def game_step(self): """Forwards the game by one step and computes the new playground Returns ------- an image with the current state of the game """ # check player positions self.player1_y, self.player1_z = self._check_player_position( self.player1_y, self.player1_z) self.player2_y, self.player2_z = self._check_player_position( self.player2_y, self.player2_z) # move puck self.puck_x = self.puck_x + self.puck_delta_x self.puck_y = self.puck_y + self.puck_delta_y self.puck_z = self.puck_z + self.puck_delta_z # check puck_position if self.puck_y < 0 or self.puck_y > self.height: self.puck_delta_y = -self.puck_delta_y self.puck_y = self.puck_y + self.puck_delta_y if self.puck_z < 0 or self.puck_z > self.depth: self.puck_delta_z = -self.puck_delta_z self.puck_z = self.puck_z + self.puck_delta_z # puck at player 1 if self.puck_x <= self.player1_x: self.puck_delta_x = -self.puck_delta_x self.puck_x = self.puck_x + self.puck_delta_x if abs(self.puck_y - self.player1_y) > self.bar_radius or abs( self.puck_z - self.player1_z) > self.bar_radius: # player 2 scores self.player2_score = self.player2_score + 1 self._level_up() else: self.puck_delta_y = (self.puck_y - self.player1_y) / self.bar_radius * 5 self.puck_delta_z = (self.puck_z - self.player1_z) / self.bar_radius * 5 # puck at player 2 if self.puck_x >= self.player2_x: self.puck_delta_x = -self.puck_delta_x self.puck_x = self.puck_x + self.puck_delta_x if abs(self.puck_y - self.player2_y) > self.bar_radius or abs( self.puck_z - self.player2_z) > self.bar_radius: # player 1 scores self.player1_score = self.player1_score + 1 self._level_up() else: self.puck_delta_y = (self.puck_y - self.player2_y) / self.bar_radius * 5 self.puck_delta_z = (self.puck_z - self.player2_z) / self.bar_radius * 5 # show game status self.result_label.setText( str(self.player1_score) + ":" + str(self.player2_score)) # draw playground cle.set(self.playground, 0.0) # draw player 1 cle.draw_box(self.playground, self.player1_x, self.player1_y - self.bar_radius, self.player1_z - self.bar_radius, 3, self.bar_radius * 2, self.bar_radius * 2) # draw player 2 cle.draw_box(self.playground, self.player2_x, self.player2_y - self.bar_radius, self.player2_z - self.bar_radius, 3, self.bar_radius * 2, self.bar_radius * 2) # draw puck cle.draw_sphere(self.playground, self.puck_x, self.puck_y, self.puck_z, 5, 3, 3, 1) # put z-color coding on playground cle.multiply_images(self.playground, self.gradient, self.view) # return playground image = cle.pull_zyx(self.view) return image
def game_step(self): """Forwards the game by one step and computes the new playground Returns ------- an image with the current state of the game """ # check player positions self.player1_position = self._check_player_position(self.player1_position) self.player2_position = self._check_player_position(self.player2_position) # move puck self.puck_x = self.puck_x + self.puck_delta_x self.puck_y = self.puck_y + self.puck_delta_y # check puck_position if self.puck_y < 0 or self.puck_y > self.height: self.puck_delta_y = -self.puck_delta_y self.puck_y = self.puck_y + self.puck_delta_y # puck at player 1 if self.puck_x <= self.player1_x: self.puck_delta_x = -self.puck_delta_x self.puck_x = self.puck_x + self.puck_delta_x if abs(self.puck_y - self.player1_position) > self.bar_radius: # player 2 scores self.player2_score = self.player2_score + 1 self._level_up() else: self.puck_delta_y = (self.puck_y - self.player1_position) / self.bar_radius * 5 # puck at player 2 if self.puck_x >= self.player2_x: self.puck_delta_x = -self.puck_delta_x self.puck_x = self.puck_x + self.puck_delta_x if abs(self.puck_y - self.player2_position) > self.bar_radius: # player 1 scores self.player1_score = self.player1_score + 1 self._level_up() else: self.puck_delta_y = (self.puck_y - self.player2_position) / self.bar_radius * 5 # show game status self.result_label.setText(str(self.player1_score) + ":" + str(self.player2_score)) # draw playground cle.set(self.playground, 0.1) # draw player 1 cle.draw_box(self.playground, self.player1_x, self.player1_position - self.bar_radius, 0, 3, self.bar_radius * 2, 0) # draw player 2 cle.draw_box(self.playground, self.player2_x, self.player2_position - self.bar_radius, 0, 3, self.bar_radius * 2, 0) # draw puck cle.draw_sphere(self.playground, self.puck_x, self.puck_y, 0, 5, 3, 1) # return playground image = cle.pull_zyx(self.playground) return image