def __init__(self,
screen,
sprite_sheet,
sheet_offsets,
pos=(0, 0),
resize=None,
detail=None,
frame_delay=None):
super().__init__()
self.screen = screen
if not resize:
resize = (self.screen.get_height() // 10,
self.screen.get_height() // 10)
self.image_manager = ImageManager(sprite_sheet,
sheet=True,
pos_offsets=sheet_offsets,
resize=resize,
animation_delay=frame_delay)
self.image, self.rect = self.image_manager.get_image()
if detail:
self.detail_piece = ImageManager(detail,
sheet=True,
pos_offsets=sheet_offsets,
resize=resize).all_images()[0]
self.image.blit(self.detail_piece, (0, 0))
else:
self.detail_piece = None
self.rect.centerx, self.rect.centery = pos
def __init__(self, cell_data=False):
self.parameters = ParametersManager()
self.image_manager = ImageManager()
self.segments_manager = None
self.cell_manager = None
self.linescan_manager = None
self.report_manager = None
self.working_dir = None
self.base_path = None
self.fluor_path = None
self.get_cell_images = cell_data
def __init__(self, cell_data=True):
self.parameters = ParametersManager()
self.image_manager = ImageManager()
self.cellcycleclassifier = CellCycleClassifier()
self.segments_manager = None
self.cell_manager = None
self.linescan_manager = None
self.coloc_manager = None
self.report_manager = None
self.working_dir = None
self.base_path = None
self.fluor_path = None
self.get_cell_images = cell_data
def go():
# get random city
city = Geo().get_location()
# get 4 images (urls)
urls = Google().search(city)
# save images
image_names = ImageManager().save(urls)
# tweet 'em
TwitterAPI().compose(city, image_names)
# clean image directory
ImageManager().delete()
# done
print('Done.')
def __init__(self, cell_data=False):
self.parameters = ParametersManager()
self.image_manager = ImageManager()
self.segments_manager = None
self.cell_manager = None
self.linescan_manager = None
self.report_manager = None
self.base_path = None
self.fluor_path = None
self.get_cell_images = cell_data
def __init__(self, screen, maze):
super().__init__()
self.screen = screen
self.maze = maze
self.push = 3
self.death = ImageManager('img/Pac.png', sheet=True, pos_offsets=[(0, 32 * 16, 32, 32),
(0, 32 * 17, 32, 32),
(0, 32*18, 32, 32),
(0, 32*19, 32, 32),
(0, 32*20, 32, 32),
(0, 32*21, 32, 32)],
resize=(self.maze.block_size - 4, self.maze.block_size - 4),
animation_delay=150, repeat=False)
self.up = ImageManager('img/Pac.png', sheet=True, pos_offsets=[(0, 32 * 4, 32, 32),
(0, 32 * 5, 32, 32),
(0, 32 * 6, 32, 32),
(0, 32 * 7, 32, 32)],
resize=(self.maze.block_size-4, self.maze.block_size-4))
self.down = ImageManager('img/Pac.png', sheet=True, pos_offsets=[(0, 32 * 12, 32, 32),
(0, 32 * 13, 32, 32),
(0, 32 * 14, 32, 32),
(0, 32 * 15, 32, 32)],
resize=(self.maze.block_size-4, self.maze.block_size-4))
self.left = ImageManager('img/Pac.png', sheet=True, pos_offsets=[(0, 32 * 8, 32, 32),
(0, 32 * 9, 32, 32),
(0, 32 * 10, 32, 32),
(0, 32 * 11, 32, 32)],
resize=(self.maze.block_size-4, self.maze.block_size-4))
self.right = ImageManager('img/Pac.png', sheet=True, pos_offsets=[(0, 0, 32, 32),
(0, 32 * 1, 32, 32),
(0, 32 * 2, 32, 32),
(0, 32 * 3, 32, 32)],
resize=(self.maze.block_size-4, self.maze.block_size-4))
self.spawn_info = self.maze.player_spawn[1]
self.tile = self.maze.player_spawn[0]
self.direction = None
self.moving = False
self.image, self.rect = self.right.get_image()
self.rect.centerx, self.rect.centery = self.spawn_info # screen coordinates for spawn
self.dead = False
self.event_map = {pygame.KEYDOWN: self.action, pygame.KEYUP: self.reset_direction}
def __init__(self, screen, initial_count=2, ct_pos=(0, 0), images_size=(32, 32)):
self.screen = screen
self.max_lives = initial_count
self.lives = initial_count
sheet_images = ImageManager('img/Pac.png', sheet=True, pos_offsets=[(0, 0, 32, 32),
(0, 32 * 1, 32, 32),
(0, 32 * 2, 32, 32),
(0, 32 * 3, 32, 32)],
resize=images_size).all_images()
life_image = sheet_images[-1]
self.life_display = ImageRow(screen, life_image, initial_count, 'Lives', ct_pos)
def __init__(self, screen):
self.screen = screen
tilesheet = TileSheet(ImageManager().load("tiles"), (32, 32))
self.level = Level("test_level", tilesheet)
self.player = Player(self.level.bounds)
self.coins = CoinGroup(self.level.bounds)
self.hud = screen.subsurface((0, 0, screen.get_width(), 40))
self.game_area = screen.subsurface(
(0, 40, screen.get_width(), screen.get_height() - 40))
self.cam = Camera(self.player, self.level.bounds,
self.game_area.get_size())
self.font = pygame.font.Font(None, 36)
self.score = 0
# create initial coins
for i in range(COIN_N_STARTING):
self.coins.spawn()
class PacMan(pygame.sprite.Sprite):
def __init__(self, screen, maze):
super().__init__()
self.screen = screen
self.maze = maze
self.push = 3
self.death = ImageManager('img/Pac.png', sheet=True, pos_offsets=[(0, 32 * 16, 32, 32),
(0, 32 * 17, 32, 32),
(0, 32*18, 32, 32),
(0, 32*19, 32, 32),
(0, 32*20, 32, 32),
(0, 32*21, 32, 32)],
resize=(self.maze.block_size - 4, self.maze.block_size - 4),
animation_delay=150, repeat=False)
self.up = ImageManager('img/Pac.png', sheet=True, pos_offsets=[(0, 32 * 4, 32, 32),
(0, 32 * 5, 32, 32),
(0, 32 * 6, 32, 32),
(0, 32 * 7, 32, 32)],
resize=(self.maze.block_size-4, self.maze.block_size-4))
self.down = ImageManager('img/Pac.png', sheet=True, pos_offsets=[(0, 32 * 12, 32, 32),
(0, 32 * 13, 32, 32),
(0, 32 * 14, 32, 32),
(0, 32 * 15, 32, 32)],
resize=(self.maze.block_size-4, self.maze.block_size-4))
self.left = ImageManager('img/Pac.png', sheet=True, pos_offsets=[(0, 32 * 8, 32, 32),
(0, 32 * 9, 32, 32),
(0, 32 * 10, 32, 32),
(0, 32 * 11, 32, 32)],
resize=(self.maze.block_size-4, self.maze.block_size-4))
self.right = ImageManager('img/Pac.png', sheet=True, pos_offsets=[(0, 0, 32, 32),
(0, 32 * 1, 32, 32),
(0, 32 * 2, 32, 32),
(0, 32 * 3, 32, 32)],
resize=(self.maze.block_size-4, self.maze.block_size-4))
self.spawn_info = self.maze.player_spawn[1]
self.tile = self.maze.player_spawn[0]
self.direction = None
self.moving = False
self.image, self.rect = self.right.get_image()
self.rect.centerx, self.rect.centery = self.spawn_info # screen coordinates for spawn
self.dead = False
self.event_map = {pygame.KEYDOWN: self.action, pygame.KEYUP: self.reset_direction}
def set_death(self):
self.dead = True
self.image, _ = self.death.get_image()
def revive(self):
self.dead = False
self.image, _ = self.right.get_image()
self.death.image_index = 0
def reset_position(self):
self.rect.centerx, self.rect.centery = self.spawn_info # screen coordinates for spawn
def reset_direction(self, event):
if event.key in (pygame.K_UP, pygame.K_DOWN, pygame.K_LEFT, pygame.K_RIGHT):
self.moving = False
def action(self, event):
if event.key == pygame.K_UP:
self.set_move_up()
if event.key == pygame.K_DOWN:
self.set_move_down()
if event.key == pygame.K_LEFT:
self.set_move_left()
if event.key == pygame.K_RIGHT:
self.set_move_right()
def set_move_up(self):
if self.direction != 'u':
self.direction = 'u'
self.moving = True
def set_move_left(self):
if self.direction != 'l':
self.direction = 'l'
self.moving = True
def set_move_down(self):
if self.direction != 'd':
self.direction = 'd'
self.moving = True
def set_move_right(self):
if self.direction != 'r':
self.direction = 'r'
self.moving = True
def push_back(self):
if self.direction == 'l':
self.rect.x += self.push
elif self.direction == 'r':
self.rect.x -= self.push
if self.direction == 'u':
self.rect.y += self.push
elif self.direction == 'd':
self.rect.y -= self.push
def pos_test(self):
test = self.rect
if self.direction == 'l':
test = self.rect.move((-1, 0))
elif self.direction == 'r':
test = self.rect.move((+1, 0))
if self.direction == 'u':
self.rect.move((0, -1))
elif self.direction == 'd':
self.rect.move((0, +1))
return test
def is_blocked(self):
while pygame.sprite.spritecollideany(self, self.maze.maze_blocks):
self.push_back()
def collide(self):
score = 0
fruit_count = 0
power = None
if pygame.sprite.spritecollideany(self, self.maze.pellets):
pygame.sprite.spritecollideany(self, self.maze.pellets).kill()
score += 10
elif pygame.sprite.spritecollideany(self, self.maze.fruits):
pygame.sprite.spritecollideany(self, self.maze.fruits).kill()
score += 20
fruit_count += 1
elif pygame.sprite.spritecollideany(self, self.maze.power_pellets):
pygame.sprite.spritecollideany(self, self.maze.power_pellets).kill()
score += 20
power = True
return score, fruit_count, power
def update(self):
if not self.dead:
self.is_blocked()
if self.direction and self.moving:
if self.direction == 'u':
self.image = self.up.next_image()
elif self.direction == 'd':
self.image = self.down.next_image()
elif self.direction == 'l':
self.image = self.left.next_image()
elif self.direction == 'r':
self.image = self.right.next_image()
if not self.is_blocked():
if self.direction == 'u':
self.rect.centery -= 1
elif self.direction == 'l':
self.rect.centerx -= 1
elif self.direction == 'd':
self.rect.centery += 1
elif self.direction == 'r':
self.rect.centerx += 1
else:
self.image = self.death.next_image()
def blit(self):
self.screen.blit(self.image, self.rect)
class EHooke(object):
"""Main class of the software.
Starts with an instance of the Parameters and Image class.
Contains the methods needed to perform the analysis"""
def __init__(self, cell_data=False):
self.parameters = ParametersManager()
self.image_manager = ImageManager()
self.segments_manager = None
self.cell_manager = None
self.linescan_manager = None
self.report_manager = None
self.base_path = None
self.fluor_path = None
self.get_cell_images = cell_data
def load_base_image(self, filename=None):
"""Calls the load_base_image method from the ImageManager
Can be called without a filename or by passing one as an arg
(filename=...)"""
if filename is None:
filename = tkFileDialog.askopenfilename()
self.base_path = filename
self.image_manager.load_base_image(filename,
self.parameters.imageloaderparams)
print "Base Image Loaded"
def compute_mask(self):
"""Calls the compute_mask method from image_manager."""
self.image_manager.compute_mask(self.parameters.imageloaderparams)
print "Mask Computation Finished"
def load_fluor_image(self, filename=None):
"""Calls the load_fluor_image method from the ImageManager
Can be called without a filename or by passing one as an arg
(filename=...)"""
if filename is None:
filename = tkFileDialog.askopenfilename()
self.fluor_path = filename
self.image_manager.load_fluor_image(self.fluor_path,
self.parameters.imageloaderparams)
print "Fluor Image Loaded"
def load_option_image(self, filename=None):
"""Calls the load_optional_image method from the ImageManager
Can be called without a filename or by passing on as an arg"""
if filename is None:
filename = tkFileDialog.askopenfilename()
self.image_manager.load_option_image(filename)
def compute_segments(self):
"""Calls the compute_segments method from Segments.
Requires the prior loading of both the phase and fluor images and
the computation of the mask"""
self.segments_manager = SegmentsManager()
self.segments_manager.compute_segments(self.parameters.
imageprocessingparams,
self.image_manager)
print "Segments Computation Finished"
def compute_cells(self):
"""Creates an instance of the CellManager class and uses the
compute_cells_method to create a list of cells based on the labels
computed by the SegmentsManager instance."""
self.cell_manager = CellManager(self.parameters)
self.cell_manager.compute_cells(self.parameters.cellprocessingparams,
self.image_manager,
self.segments_manager)
print "Cells Computation Finished"
def merge_cells(self, label_c1, label_c2):
"""Merges two cells using the merge_cells method from the cell_manager
instance and the compute_merged_cells to create a new list of cells,
containing a cell corresponding to the merge of the previous two."""
self.cell_manager.merge_cells(label_c1, label_c2,
self.parameters.cellprocessingparams,
self.segments_manager,
self.image_manager)
self.cell_manager.overlay_cells(self.image_manager)
print "Merge Finished"
def split_cells(self, label_c1):
"""Splits a previously merged cell, requires the label of cell to be
splitted.
Calls the split_cells method from the cell_manager instance"""
self.cell_manager.split_cells(int(label_c1),
self.parameters.cellprocessingparams,
self.segments_manager,
self.image_manager)
self.cell_manager.overlay_cells(self.image_manager)
print "Split Finished"
def define_as_noise(self, label_c1, noise):
"""Method used to change the state of a cell to noise or to undo it"""
self.cell_manager.mark_cell_as_noise(label_c1, self.image_manager,
noise)
def process_cells(self):
"""Process the list of computed cells to identify the different regions
of each cell and computes the stats related to the fluorescence"""
self.cell_manager.process_cells(self.parameters.cellprocessingparams,
self.image_manager)
self.linescan_manager = LineScanManager()
print "Processing Cells Finished"
def add_line_linescan(self, point_1, point_2, point_3):
self.linescan_manager.add_line(point_1, point_2, point_3)
def remove_line_linescan(self, line_id):
self.linescan_manager.remove_line(line_id)
def select_all_cells(self):
"""Method used to mark all the cells as selected"""
for k in self.cell_manager.cells.keys():
if self.cell_manager.cells[k].selection_state != 0:
self.cell_manager.cells[k].selection_state = 1
self.cell_manager.overlay_cells(self.image_manager)
def reject_all_cells(self):
"""Method used to mark all the cells as rejected"""
for k in self.cell_manager.cells.keys():
if self.cell_manager.cells[k].selection_state != 0:
self.cell_manager.cells[k].selection_state = -1
self.cell_manager.overlay_cells(self.image_manager)
def select_from_file(self, filename=None):
if filename is None:
filename = tkFileDialog.askopenfilename()
o_file = open(filename)
data = o_file.readlines()
o_file.close()
data = data[0].split(";")[:len(data[0].split(";")) - 1]
for key in data:
self.cell_manager.cells[key].selection_state = 1
self.cell_manager.overlay_cells(self.image_manager)
def filter_cells(self):
"""Filters the cell based on the filters defined in the
params.cellprocessingparams. Calls the filter_cells method from the
cell_manager instance"""
self.cell_manager.filter_cells(self.parameters.cellprocessingparams,
self.image_manager)
print "Finished Filtering Cells"
def generate_reports(self, filename=None, label=None):
"""Generates the report files by calling the generate_report method
from Reports"""
if filename is None:
filename = tkFileDialog.askdirectory()
if label is None:
label = self.fluor_path.split("/")
label = label[len(label) - 1].split(".")[0]
if len(self.linescan_manager.lines.keys()) > 0:
self.linescan_manager.measure_fluorescence(
self.image_manager.fluor_image)
self.report_manager = ReportManager(self.parameters)
self.report_manager.generate_report(filename, label,
self.cell_manager,
self.linescan_manager,
self.parameters)
if self.get_cell_images:
self.report_manager.get_cell_images(filename, label,
self.image_manager,
self.cell_manager,
self.parameters)
print "Reports Generated"
class EHooke(object):
"""Main class of the software.
Starts with an instance of the Parameters and Image class.
Contains the methods needed to perform the analysis"""
def __init__(self, cell_data=False):
self.parameters = ParametersManager()
self.image_manager = ImageManager()
self.segments_manager = None
self.cell_manager = None
self.linescan_manager = None
self.report_manager = None
self.working_dir = None
self.base_path = None
self.fluor_path = None
self.get_cell_images = cell_data
def load_base_image(self, filename=None):
"""Calls the load_base_image method from the ImageManager
Can be called without a filename or by passing one as an arg
(filename=...)"""
if filename is None:
filename = tkFileDialog.askopenfilename(
initialdir=self.working_dir)
self.working_dir = "/".join(
filename.split("/")[:len(filename.split("/")) - 1])
self.base_path = filename
self.image_manager.load_base_image(filename,
self.parameters.imageloaderparams)
print "Base Image Loaded"
def compute_mask(self):
"""Calls the compute_mask method from image_manager."""
self.image_manager.compute_mask(self.parameters.imageloaderparams)
if self.image_manager.fluor_image is not None:
self.load_fluor_image(self.fluor_path)
print "Mask Computation Finished"
def load_fluor_image(self, filename=None):
"""Calls the load_fluor_image method from the ImageManager
Can be called without a filename or by passing one as an arg
(filename=...)"""
if filename is None:
filename = tkFileDialog.askopenfilename(
initialdir=self.working_dir)
self.fluor_path = filename
self.image_manager.load_fluor_image(self.fluor_path,
self.parameters.imageloaderparams)
print "Fluor Image Loaded"
def load_option_image(self, filename=None):
"""Calls the load_optional_image method from the ImageManager
Can be called without a filename or by passing on as an arg"""
if filename is None:
filename = tkFileDialog.askopenfilename()
self.image_manager.load_option_image(filename)
def compute_segments(self):
"""Calls the compute_segments method from Segments.
Requires the prior loading of both the phase and fluor images and
the computation of the mask"""
self.segments_manager = SegmentsManager()
self.segments_manager.compute_segments(
self.parameters.imageprocessingparams, self.image_manager)
print "Segments Computation Finished"
def compute_cells(self):
"""Creates an instance of the CellManager class and uses the
compute_cells_method to create a list of cells based on the labels
computed by the SegmentsManager instance."""
self.cell_manager = CellManager(self.parameters)
self.cell_manager.compute_cells(self.parameters.cellprocessingparams,
self.image_manager,
self.segments_manager)
print "Cells Computation Finished"
def merge_cells(self, label_c1, label_c2):
"""Merges two cells using the merge_cells method from the cell_manager
instance and the compute_merged_cells to create a new list of cells,
containing a cell corresponding to the merge of the previous two."""
self.cell_manager.merge_cells(label_c1, label_c2,
self.parameters.cellprocessingparams,
self.segments_manager,
self.image_manager)
self.cell_manager.overlay_cells(self.image_manager)
print "Merge Finished"
def split_cells(self, label_c1):
"""Splits a previously merged cell, requires the label of cell to be
splitted.
Calls the split_cells method from the cell_manager instance"""
self.cell_manager.split_cells(int(label_c1),
self.parameters.cellprocessingparams,
self.segments_manager,
self.image_manager)
self.cell_manager.overlay_cells(self.image_manager)
print "Split Finished"
def define_as_noise(self, label_c1, noise):
"""Method used to change the state of a cell to noise or to undo it"""
self.cell_manager.mark_cell_as_noise(label_c1, self.image_manager,
noise)
def process_cells(self):
"""Process the list of computed cells to identify the different regions
of each cell and computes the stats related to the fluorescence"""
self.cell_manager.process_cells(self.parameters.cellprocessingparams,
self.image_manager)
self.linescan_manager = LineScanManager()
print "Processing Cells Finished"
def add_line_linescan(self, point_1, point_2, point_3):
self.linescan_manager.add_line(point_1, point_2, point_3)
def remove_line_linescan(self, line_id):
self.linescan_manager.remove_line(line_id)
def select_all_cells(self):
"""Method used to mark all the cells as selected"""
for k in self.cell_manager.cells.keys():
if self.cell_manager.cells[k].selection_state != 0:
self.cell_manager.cells[k].selection_state = 1
self.cell_manager.overlay_cells(self.image_manager)
def reject_all_cells(self):
"""Method used to mark all the cells as rejected"""
for k in self.cell_manager.cells.keys():
if self.cell_manager.cells[k].selection_state != 0:
self.cell_manager.cells[k].selection_state = -1
self.cell_manager.overlay_cells(self.image_manager)
def select_from_file(self, filename=None):
if filename is None:
filename = tkFileDialog.askopenfilename()
o_file = open(filename)
data = o_file.readlines()
o_file.close()
data = data[0].split(";")[:len(data[0].split(";")) - 1]
for key in data:
self.cell_manager.cells[key].selection_state = 1
self.cell_manager.overlay_cells(self.image_manager)
def filter_cells(self):
"""Filters the cell based on the filters defined in the
params.cellprocessingparams. Calls the filter_cells method from the
cell_manager instance"""
self.cell_manager.filter_cells(self.parameters.cellprocessingparams,
self.image_manager)
print "Finished Filtering Cells"
def generate_reports(self, filename=None, label=None):
"""Generates the report files by calling the generate_report method
from Reports"""
if filename is None:
filename = tkFileDialog.askdirectory()
if label is None:
label = self.fluor_path.split("/")
label = label[len(label) - 1].split(".")
if len(label) > 2:
label = label[len(label) - 3] + "." + label[len(label) - 2]
else:
label = label[len(label) - 2]
if len(self.linescan_manager.lines.keys()) > 0:
self.linescan_manager.measure_fluorescence(
self.image_manager.fluor_image)
self.report_manager = ReportManager(self.parameters)
self.report_manager.generate_report(filename, label, self.cell_manager,
self.linescan_manager,
self.parameters)
if self.get_cell_images:
self.report_manager.get_cell_images(filename, label,
self.image_manager,
self.cell_manager,
self.parameters)
print "Reports Generated"
def __init__(self, w, h, pos):
img, _ = ImageManager('img/berry.png',
resize=(w // 2, h // 2)).get_image()
super(Berry, self).__init__(w, h, pos, img)
class EHooke(object):
"""Main class of the software.
Starts with an instance of the Parameters and Image class.
Contains the methods needed to perform the analysis
"""
def __init__(self, cell_data=True):
self.parameters = ParametersManager()
self.image_manager = ImageManager()
self.cellcycleclassifier = CellCycleClassifier()
self.segments_manager = None
self.cell_manager = None
self.linescan_manager = None
self.coloc_manager = None
self.report_manager = None
self.working_dir = None
self.base_path = None
self.fluor_path = None
self.get_cell_images = cell_data
def load_base_image(self, filename=None):
"""Calls the load_base_image method from the ImageManager
Can be called without a filename or by passing one as an arg
(filename=...)
"""
if filename is None:
filename = tkFileDialog.askopenfilename(
initialdir=self.working_dir)
self.working_dir = "/".join(
filename.split("/")[:len(filename.split("/")) - 1])
self.base_path = filename
self.image_manager.load_base_image(filename,
self.parameters.imageloaderparams)
print("Base Image Loaded")
def compute_mask(self):
"""Calls the compute_mask method from image_manager."""
self.image_manager.compute_mask(self.parameters.imageloaderparams)
if self.image_manager.fluor_image is not None:
self.load_fluor_image(self.fluor_path)
print("Mask Computation Finished")
def load_fluor_image(self, filename=None):
"""Calls the load_fluor_image method from the ImageManager
Can be called without a filename or by passing one as an arg
(filename=...)
"""
if filename is None:
filename = tkFileDialog.askopenfilename(
initialdir=self.working_dir)
self.fluor_path = filename
self.image_manager.load_fluor_image(filename,
self.parameters.imageloaderparams)
print("Fluor Image Loaded")
def load_option_image(self, filename=None):
"""Calls the load_optional_image method from the ImageManager
Can be called without a filename or by passing on as an arg
"""
if filename is None:
filename = tkFileDialog.askopenfilename(
initialdir=self.working_dir)
self.image_manager.load_option_image(filename,
self.parameters.imageloaderparams)
def compute_segments(self):
"""Calls the compute_segments method from Segments.
Requires the prior loading of both the phase and fluor images and
the computation of the mask
"""
self.segments_manager = SegmentsManager()
self.segments_manager.compute_segments(
self.parameters.imageprocessingparams, self.image_manager)
print("Segments Computation Finished")
def compute_cells(self):
"""Creates an instance of the CellManager class and uses the
compute_cells_method to create a list of cells based on the labels
computed by the SegmentsManager instance.
"""
self.cell_manager = CellManager(self.parameters)
self.cell_manager.compute_cells(self.parameters, self.image_manager,
self.segments_manager)
print("Cells Computation Finished")
def merge_cells(self, label_c1, label_c2):
"""Merges two cells using the merge_cells method from the cell_manager
instance and the compute_merged_cells to create a new list of cells,
containing a cell corresponding to the merge of the previous two.
"""
self.cell_manager.merge_cells(label_c1, label_c2, self.parameters,
self.segments_manager,
self.image_manager)
self.cell_manager.overlay_cells(self.image_manager)
print("Merge Finished")
def split_cells(self, label_c1):
"""Splits a previously merged cell, requires the label of cell to be
splitted.
Calls the split_cells method from the cell_manager instance
"""
self.cell_manager.split_cells(int(label_c1), self.parameters,
self.segments_manager,
self.image_manager)
self.cell_manager.overlay_cells(self.image_manager)
print("Split Finished")
def define_as_noise(self, label_c1, noise):
"""Method used to change the state of a cell to noise or to undo it"""
self.cell_manager.mark_cell_as_noise(label_c1, self.image_manager,
noise)
def process_cells(self):
"""Process the list of computed cells to identify the different regions
of each cell and computes the stats related to the fluorescence
"""
self.cell_manager.process_cells(self.parameters.cellprocessingparams,
self.image_manager)
self.linescan_manager = LineScanManager()
if self.parameters.cellprocessingparams.classify_cells:
self.compute_cellcyclephases()
else:
for k in self.cell_manager.cells.keys():
self.cell_manager.cells[k].stats["Cell Cycle Phase"] = 0
print("Processing Cells Finished")
def select_cells_phase(self, phase):
"""Helper function for GUI. For each cell in a specific (user defined) cell phase,
sets the selection flag to a boolean True (1)
"""
for k in self.cell_manager.cells.keys():
if self.cell_manager.cells[k].stats["Cell Cycle Phase"] == phase:
self.cell_manager.cells[k].selection_state = 1
self.cell_manager.overlay_cells(self.image_manager)
def add_line_linescan(self, point_1, point_2, point_3):
""" Helper function for GUI. Adds a line given three user defined points."""
self.linescan_manager.add_line(point_1, point_2, point_3)
def remove_line_linescan(self, line_id):
""" Helper function for GUI. Removes a user specified line."""
self.linescan_manager.remove_line(line_id)
def select_all_cells(self):
"""Method used to mark all the cells as selected"""
for k in self.cell_manager.cells.keys():
if self.cell_manager.cells[k].selection_state != 0:
self.cell_manager.cells[k].selection_state = 1
self.cell_manager.overlay_cells(self.image_manager)
def reject_all_cells(self):
"""Method used to mark all the cells as rejected"""
for k in self.cell_manager.cells.keys():
if self.cell_manager.cells[k].selection_state != 0:
self.cell_manager.cells[k].selection_state = -1
self.cell_manager.overlay_cells(self.image_manager)
def invert_selection(self):
for k in self.cell_manager.cells.keys():
self.cell_manager.cells[k].selection_state *= -1
self.cell_manager.overlay_cells(self.image_manager)
def select_from_file(self, filename=None):
"""Selects cells based upon a user fed txt file. Assumes correct formatting of said file"""
if filename is None:
filename = tkFileDialog.askopenfilename()
o_file = open(filename)
data = o_file.readlines()
o_file.close()
data = data[0].split(";")[:len(data[0].split(";")) - 1]
for key in data:
self.cell_manager.cells[key].selection_state = 1
self.cell_manager.overlay_cells(self.image_manager)
def filter_cells(self):
"""Filters the cell based on the filters defined in the
params.cellprocessingparams. Calls the filter_cells method from the
cell_manager instance
"""
self.cell_manager.filter_cells(self.parameters.cellprocessingparams,
self.image_manager)
print("Finished Filtering Cells")
def compute_coloc(self, label=None):
"""Calls the necessary method to calculate colocalization (through PCC) of two proteins.
REQUIRES an additional optional fluorescent image
"""
if label is None:
label = self.fluor_path.split("/")
label = label[len(label) - 1].split(".")
if len(label) > 2:
label = label[len(label) - 3] + "." + label[len(label) - 2]
else:
label = label[len(label) - 2]
# TODO facilitate user experience by separating the different optional images (PCC, DNA, etc)
if self.image_manager.optional_image is not None:
self.coloc_manager = ColocManager()
self.coloc_manager.compute_pcc(self.cell_manager,
self.image_manager, self.parameters,
label)
else:
print("Optional Image not loaded")
def compute_cellcyclephases(self):
self.cellcycleclassifier.classify_cells(
self.image_manager, self.cell_manager,
self.parameters.cellprocessingparams.microscope)
def select_cells_optional(self, signal_ratio):
if self.image_manager.optional_image is not None:
self.cell_manager.select_cells_optional(signal_ratio,
self.image_manager)
self.cell_manager.overlay_cells(self.image_manager)
else:
print("No optional image loaded")
def assign_cell_cycle_phase(self, key, phase):
self.cell_manager.cells[key].stats["Cell Cycle Phase"] = int(phase)
def generate_reports(self, filename=None, label=None):
"""Generates the report files by calling the generate_report method
from Reports
"""
if filename is None:
filename = tkFileDialog.askdirectory(initialdir=self.working_dir)
if label is None:
label = self.fluor_path.split("/")
label = label[len(label) - 1].split(".")
if len(label) > 2:
label = label[len(label) - 3] + "." + label[len(label) - 2]
else:
label = label[len(label) - 2]
if len(self.linescan_manager.lines.keys()) > 0:
self.linescan_manager.measure_fluorescence(
self.image_manager.fluor_image)
self.report_manager = ReportManager(self.parameters)
self.report_manager.generate_report(filename, label, self.cell_manager,
self.linescan_manager,
self.parameters)
if self.get_cell_images:
self.report_manager.get_cell_images(filename, label,
self.image_manager,
self.cell_manager,
self.parameters)
print("Reports Generated")
def save_mask(self):
self.image_manager.save_mask()
def save_labels(self):
self.segments_manager.save_labels()
def __init__(self, screen, maze, info, file):
super().__init__()
self.screen = screen
self.maze = maze
self.kill_able = ImageManager('img/Gos.png',
sheet=True,
pos_offsets=[(0, 32 * 8, 32, 32),
(0, 32 * 9, 32, 32)],
resize=(self.maze.block_size,
self.maze.block_size),
animation_delay=150)
self.orange = ImageManager('img/Gos.png',
sheet=True,
pos_offsets=[(0, 32 * 0, 32, 32),
(0, 32 * 1, 32, 32)],
resize=(self.maze.block_size,
self.maze.block_size),
animation_delay=250)
self.red = ImageManager('img/Gos.png',
sheet=True,
pos_offsets=[(0, 32 * 2, 32, 32),
(0, 32 * 3, 32, 32)],
resize=(self.maze.block_size,
self.maze.block_size),
animation_delay=250)
self.cyan = ImageManager('img/Gos.png',
sheet=True,
pos_offsets=[(0, 32 * 4, 32, 32),
(0, 32 * 5, 32, 32)],
resize=(self.maze.block_size,
self.maze.block_size),
animation_delay=250)
self.pink = ImageManager('img/Gos.png',
sheet=True,
pos_offsets=[(0, 32 * 6, 32, 32),
(0, 32 * 7, 32, 32)],
resize=(self.maze.block_size,
self.maze.block_size),
animation_delay=250)
self.images = self.red
if file == 'orange':
self.images = self.orange
elif file == 'cyan':
self.images = self.cyan
elif file == 'pink':
self.images = self.pink
self.score_font = pygame.font.Font('fonts/Lumberjack-Regular.ttf', 18)
self.score_image = None
self.image, self.rect = self.images.get_image()
self.return_tile = info[0]
self.eaten_time = None
self.start_pos = info[1]
self.reset_position()
self.on = False
self.kill = False
self.ret = False
class Ghost(Sprite):
def __init__(self, screen, maze, info, file):
super().__init__()
self.screen = screen
self.maze = maze
self.kill_able = ImageManager('img/Gos.png',
sheet=True,
pos_offsets=[(0, 32 * 8, 32, 32),
(0, 32 * 9, 32, 32)],
resize=(self.maze.block_size,
self.maze.block_size),
animation_delay=150)
self.orange = ImageManager('img/Gos.png',
sheet=True,
pos_offsets=[(0, 32 * 0, 32, 32),
(0, 32 * 1, 32, 32)],
resize=(self.maze.block_size,
self.maze.block_size),
animation_delay=250)
self.red = ImageManager('img/Gos.png',
sheet=True,
pos_offsets=[(0, 32 * 2, 32, 32),
(0, 32 * 3, 32, 32)],
resize=(self.maze.block_size,
self.maze.block_size),
animation_delay=250)
self.cyan = ImageManager('img/Gos.png',
sheet=True,
pos_offsets=[(0, 32 * 4, 32, 32),
(0, 32 * 5, 32, 32)],
resize=(self.maze.block_size,
self.maze.block_size),
animation_delay=250)
self.pink = ImageManager('img/Gos.png',
sheet=True,
pos_offsets=[(0, 32 * 6, 32, 32),
(0, 32 * 7, 32, 32)],
resize=(self.maze.block_size,
self.maze.block_size),
animation_delay=250)
self.images = self.red
if file == 'orange':
self.images = self.orange
elif file == 'cyan':
self.images = self.cyan
elif file == 'pink':
self.images = self.pink
self.score_font = pygame.font.Font('fonts/Lumberjack-Regular.ttf', 18)
self.score_image = None
self.image, self.rect = self.images.get_image()
self.return_tile = info[0]
self.eaten_time = None
self.start_pos = info[1]
self.reset_position()
self.on = False
self.kill = False
self.ret = False
def reset_position(self):
self.rect.left, self.rect.top = self.start_pos
def set_eaten(self):
self.ret = True
self.kill = False
self.image = self.score_font.render('200', True, Colors().white)
def trigger(self):
if not self.ret:
self.kill = True
self.image, _ = self.kill_able.get_image()
def enable(self):
self.on = True
def update_normal(self):
self.image = self.images.next_image()
def update_blue(self):
self.image = self.kill_able.next_image()
def update(self):
if self.on:
if not self.kill:
self.update_normal()
else:
self.update_blue()
def blit(self):
self.screen.blit(self.image, self.rect)
