def __init__(self):
self.parameters = ParametersManager()
self.image_manager = ImageManager()
self.segments_manager = SegmentsManager()
self.cells_manager = None
self.fret_manager = FRETManager()
self.reports_manager = ReportsManager(self.parameters)
self.control_params = None
self.working_dir = None
def __init__(self, pos, screen, index):
filename = os.path.join('data','T_trees2','trees2 tileset.bmp')
ImageManager().loadStatic(filename, 'Tree2')
tileset = ImageManager().getStatic('Tree2')
self.image = pygame.Surface((128,128))
x,y = 128*(index % 4), 128*int(index / 4)
self.image.blit(tileset, (0,0), pygame.Rect(x,y,128,128))
self.image.set_colorkey(self.image.get_at((0,0)))
self.rect = self.image.get_rect()
Stat.__init__(self, pos, screen)
class CoLoc(object):
"""Placeholder"""
def __init__(self):
self.image_manager = ImageManager()
self.cell_manager = CellManager()
self.coloc_processor = CoLocProcessor()
self.reports_manager = ReportsManager()
self.cell_picker = CellPicker()
def load_images(self):
"""Placeholder"""
self.image_manager.load_images()
def create_mask(self):
"""Placeholder"""
self.image_manager.create_cells_mask()
def process_cells(self):
"""Placeholder"""
self.cell_manager.process_cells(self.image_manager.cells_mask)
def pearsons_test(self):
"""Placeholder"""
self.coloc_processor.pearsons_test(self.image_manager, self.cell_manager)
def pearsons_test_percentile(self):
"""Placeholder"""
self.coloc_processor.cell_pearsons_test_percentile(self.image_manager,
self.cell_manager,
0.3)
def select_cells(self):
self.cell_picker.select_cells(self.cell_manager)
def generate_pearsons_report(self):
"""Placeholder"""
self.reports_manager.pearsons_report(self.image_manager, self.cell_manager,
self.coloc_processor)
def generate_pearsons_report_percentile(self):
"""Placeholder"""
self.reports_manager.pearsons_report_percentile(self.image_manager,
self.cell_manager,
self.coloc_processor)
class Bullet:
def __init__(self, screen, site, nature):
self.site = site
self.screen = screen
self.nature = nature
self.imagemanager = ImageManager()
def move(self):
if self.nature == 'plane':
self.site[1] = self.site[1] - 0.5 #元组不支持修改删除
elif self.nature == 'enemy':
self.site[1] += 0.5
def show(self):
if self.nature == 'plane':
self.screen.blit(self.imagemanager.get_plane_bullet(),
(USIZE * self.site[0], USIZE * self.site[1]))
elif self.nature == 'enemy':
self.screen.blit(self.imagemanager.get_enemy_bullet(),
(USIZE * self.site[0], USIZE * self.site[1]))
class Enemy:
def __init__(self, screen, site):
self.screen = screen
self.site = site
self.imagemanager = ImageManager()
def move(self):
self.site[1] += 0.2
def show(self):
self.screen.blit(self.imagemanager.get_enemy(),
(USIZE * self.site[0], USIZE * self.site[1]))
class Parachute:
def __init__(self, screen, site):
self.screen = screen
self.site = site
self.imagemanager = ImageManager()
def move(self):
self.site[1] += 0.4
def show(self):
self.screen.blit(self.imagemanager.get_parachute(),
(USIZE * self.site[0], USIZE * self.site[1]))
def __init__(self, screen):
self.screen = screen
# Sprite groups
self.AllSprites = depthupdates.DepthUpdates()
self.Dinos = depthupdates.DepthUpdates()
self.Ogres = depthupdates.DepthUpdates()
self.Trees = depthupdates.DepthUpdates()
# Create background
grassfile = os.path.join('ReinerLevel', 'data', 'Tgrundvari',
'variationen', '012.bmp')
ImageManager().loadStatic(grassfile, 'Grass', colorkey=False)
grassimage = ImageManager().getStatic('Grass')
self.background = pygame.Surface(screen.get_size())
for x in range(0, self.background.get_width(), grassimage.get_width()):
for y in range(0, self.background.get_height(),
grassimage.get_height()):
self.background.blit(grassimage, (x, y))
# Create game objects
w, h = self.screen.get_size()
for i in range(5):
x, y = randint(0, w - 1), randint(0, h - 1)
d = Dino((x, y), screen)
d.speed = randint(0, 5)
d.heading = randint(0, 7)
self.Dinos.add(d)
for i in range(5):
x, y = randint(0, w - 1), randint(0, h - 1)
o = Ogre((x, y), screen)
o.speed = randint(0, 5)
o.heading = randint(0, 7)
self.Ogres.add(o)
for i in range(42):
x, y = randint(0, w - 1), randint(0, h - 1)
t = Tree2((x, y), screen, i % 21)
self.Trees.add(t)
self.myogre = self.Ogres.sprites()[0]
self.AllSprites.add(self.Dinos, self.Ogres, self.Trees)
def __init__(self, screen):
self.screen = screen
# Sprite groups
self.AllSprites = depthupdates.DepthUpdates()
self.Dinos = depthupdates.DepthUpdates()
self.Ogres = depthupdates.DepthUpdates()
self.Trees = depthupdates.DepthUpdates()
# Create background
grassfile = os.path.join('ReinerLevel','data','Tgrundvari','variationen','012.bmp')
ImageManager().loadStatic(grassfile,'Grass',colorkey=False)
grassimage = ImageManager().getStatic('Grass')
self.background = pygame.Surface(screen.get_size())
for x in range(0,self.background.get_width(),grassimage.get_width()):
for y in range(0,self.background.get_height(),grassimage.get_height()):
self.background.blit(grassimage, (x,y))
# Create game objects
w,h = self.screen.get_size()
for i in range(5):
x,y = randint(0,w-1), randint(0,h-1)
d = Dino((x,y), screen)
d.speed = randint(0,5)
d.heading = randint(0,7)
self.Dinos.add(d)
for i in range(5):
x,y = randint(0,w-1), randint(0,h-1)
o = Ogre((x,y), screen)
o.speed = randint(0,5)
o.heading = randint(0,7)
self.Ogres.add(o)
for i in range(42):
x,y = randint(0,w-1),randint(0,h-1)
t = Tree2((x,y), screen, i%21)
self.Trees.add(t)
self.myogre = self.Ogres.sprites()[0]
self.AllSprites.add(self.Dinos, self.Ogres, self.Trees)
class Plane:
def __init__(self, screen):
self.site = [CLOUMNS / 2 - 1, ROWS - 3]
self.screen = screen
self.imagemanager = ImageManager()
def move(self, state):
if state == 'left' and self.site[0] > 0:
self.site[0] -= 1
elif state == 'right' and self.site[0] < CLOUMNS - 2:
self.site[0] += 1
else:
pass
def shoot(self):
return Bullet(self.screen, [self.site[0] + 1.5, self.site[1]], 'plane')
def show1(self):
self.screen.blit(self.imagemanager.get_plane1(),
(USIZE * self.site[0], USIZE * self.site[1]))
def show2(self):
self.screen.blit(self.imagemanager.get_plane2(),
(USIZE * self.site[0], USIZE * self.site[1]))
class EnemyKing:
def __init__(self, screen, site):
self.screen = screen
self.site = site
self.imagemanager = ImageManager()
def move(self):
self.site[1] += 0.08
def show(self, times):
self.screen.blit(self.imagemanager.get_enemy_king(times),
(USIZE * self.site[0], USIZE * self.site[1]))
def shoot(self):
return Bullet(self.screen, [self.site[0] + 2.5, self.site[1] + 7],
'enemy')
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode(size)
self.soundmanager = SoundManager()
self.imagemanager = ImageManager()
self.plane = Plane(self.screen)
self.STATE = 'waiting'
self.enemykingexist = False
self.parachuteexist = False
self.enemylist = []
self.bulletlist = []
self.enemybulletlist = []
self.score = 0
self.level = 0
self.chance = 5
self.chioce = 0 #select difficulty
self.degree = DEGREE[self.chioce]
self.speed = self.degree['initspeed']
self.enemykingtimes = 0
self.clock = 0
def main():
# Initialize display
pygame.init()
#screen_size = (800,600)
screen = pygame.display.set_mode(screen_size)
pygame.display.set_caption('Depth updates.')
# Create background
grassfile = os.path.join('data','Tgrundvari','variationen','012.bmp')
ImageManager().loadStatic(grassfile,'Grass',colorkey=False)
grassimage = ImageManager().getStatic('Grass')
background = pygame.Surface(screen.get_size())
for x in range(0,background.get_width(),grassimage.get_width()):
for y in range(0,background.get_height(),grassimage.get_height()):
background.blit(grassimage, (x,y))
# Create game objects
w,h = screen.get_size()
for i in range(5):
x,y = randint(0,w-1), randint(0,h-1)
d = Dino((x,y), screen)
d.speed = randint(0,5)
d.heading = randint(0,7)
Dinos.add(d)
for i in range(5):
x,y = randint(0,w-1), randint(0,h-1)
o = Ogre((x,y), screen)
o.speed = randint(0,5)
o.heading = randint(0,7)
Ogres.add(o)
for i in range(20):
x,y = randint(0,w-1),randint(0,h-1)
t = Tree2((x,y), screen, i%21)
Trees.add(t)
myogre = Ogres.sprites()[0]
Mobs.add(Dinos, Ogres)
Stats.add(Trees)
AllSprites.add(Mobs, Stats)
# Create clock
clock = pygame.time.Clock()
# Game loop
while 1:
# Slow game down to 30 fps:
clock.tick(30)
# Event queue handling:
for event in pygame.event.get():
if event.type == QUIT:
return
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
return
elif event.key == K_RIGHT:
myogre.heading -= 1
myogre.heading %= 8
elif event.key == K_LEFT:
myogre.heading += 1
myogre.heading %= 8
# Event polling:
pressed = pygame.key.get_pressed()
if pressed[K_UP]:
myogre.speed = 4.0
else:
myogre.speed = 0.0
# Update:
AllSprites.update()
for spr1 in Stats:
for spr2 in [myogre]:
if spr1 != spr2:
if pygame.Rect.colliderect(spr1.collisionRect,
spr2.collisionRect):
#spr1.backup()
spr2.backup()
# Draw everything:
screen.blit(background, (0,0))
red = pygame.Color("red")
pygame.draw.rect(screen, red, myogre.rect, 1)
pygame.draw.rect(screen, red, myogre.collisionRect, 1)
for spr in Stats:
pygame.draw.rect(screen, red, spr.collisionRect, 1)
AllSprites.draw(screen)
pygame.display.flip()
def __init__(self, pos, screen):
folder = os.path.join('ReinerLevel', 'data', 'T_ogre',
'ogre 96x bitmaps')
ImageManager().loadAnimations(folder, 'Ogre')
animations = ImageManager().getAnimations('Ogre')
ReinerMob.__init__(self, pos, screen, animations)
def __init__(self, pos, screen):
folder = os.path.join('ReinerLevel', 'data', 'T_dino_red',
'dino red bitmaps')
ImageManager().loadAnimations(folder, 'Dino')
animations = ImageManager().getAnimations('Dino')
ReinerMob.__init__(self, pos, screen, animations)
def __init__(self):
self.image_manager = ImageManager()
self.cell_manager = CellManager()
self.coloc_processor = CoLocProcessor()
self.reports_manager = ReportsManager()
self.cell_picker = CellPicker()
def test_create(self):
im = ImageManager()
im.download("matrix")
self.assertTrue(im)
class SetManager(object):
def __init__(self):
self.parameters = ParametersManager()
self.image_manager = ImageManager()
self.segments_manager = SegmentsManager()
self.cells_manager = None
self.fret_manager = FRETManager()
self.reports_manager = ReportsManager(self.parameters)
self.control_params = None
self.working_dir = None
def load_phase_image(self, filename=None):
if filename is None:
filename = tkFileDialog.askopenfilename(initialdir=self.working_dir)
self.working_dir = "/".join(filename.split("/")[:len(filename.split("/"))-1])
self.image_manager.load_phase_image(filename,
self.parameters.imageloaderparams.border)
print "Phase 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, channel, 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.image_manager.load_fluor_image(channel,
self.parameters.imageloaderparams,
filename)
print "Fluor Image Loaded"
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.cells_manager = CellsManager(self.parameters)
self.cells_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.cells_manager.merge_cells(label_c1, label_c2,
self.parameters.cellprocessingparams,
self.segments_manager,
self.image_manager)
self.cells_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.cells_manager.split_cells(int(label_c1),
self.parameters.cellprocessingparams,
self.segments_manager,
self.image_manager)
self.cells_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.cells_manager.mark_cell_as_noise(label_c1, self.image_manager,
noise)
def process_cells(self):
self.cells_manager.process_cells(self.parameters.cellprocessingparams, self.image_manager)
print "Cells Processing Finished"
def pick_channel(self):
self.fret_manager.start_channel_picker(self.image_manager, self.cells_manager)
def compute_autofluorescence(self):
self.fret_manager.compute_autofluorescence(self.image_manager, self.cells_manager)
def compute_correction_factors(self):
self.fret_manager.compute_correction_factors(self.image_manager, self.cells_manager)
def compute_g(self):
self.fret_manager.compute_g(self.image_manager, self.cells_manager)
def compute_fret_efficiency(self):
self.fret_manager.compute_fret_efficiency(self.image_manager, self.cells_manager)
def generate_report(self):
self.reports_manager.generate_report(self.image_manager, self.cells_manager, self.fret_manager)
def __init__(self, screen):
self.site = [CLOUMNS / 2 - 1, ROWS - 3]
self.screen = screen
self.imagemanager = ImageManager()
def main():
# Initialize display
pygame.init()
#screen_size = (800,600)
screen = pygame.display.set_mode(screen_size)
pygame.display.set_caption('Depth updates.')
# Create background
grassfile = os.path.join('data', 'Tgrundvari', 'variationen', '012.bmp')
ImageManager().loadStatic(grassfile, 'Grass', colorkey=False)
grassimage = ImageManager().getStatic('Grass')
background = pygame.Surface(screen.get_size())
for x in range(0, background.get_width(), grassimage.get_width()):
for y in range(0, background.get_height(), grassimage.get_height()):
background.blit(grassimage, (x, y))
# Create game objects
w, h = screen.get_size()
for i in range(5):
x, y = randint(0, w - 1), randint(0, h - 1)
d = Dino((x, y), screen)
d.speed = randint(0, 5)
d.heading = randint(0, 7)
Dinos.add(d)
for i in range(5):
x, y = randint(0, w - 1), randint(0, h - 1)
o = Ogre((x, y), screen)
o.speed = randint(0, 5)
o.heading = randint(0, 7)
Ogres.add(o)
for i in range(20):
x, y = randint(0, w - 1), randint(0, h - 1)
t = Tree2((x, y), screen, i % 21)
Trees.add(t)
myogre = Ogres.sprites()[0]
Mobs.add(Dinos, Ogres)
Stats.add(Trees)
AllSprites.add(Mobs, Stats)
# Create clock
clock = pygame.time.Clock()
# Game loop
while 1:
# Slow game down to 30 fps:
clock.tick(30)
# Event queue handling:
for event in pygame.event.get():
if event.type == QUIT:
return
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
return
elif event.key == K_RIGHT:
myogre.heading -= 1
myogre.heading %= 8
elif event.key == K_LEFT:
myogre.heading += 1
myogre.heading %= 8
# Event polling:
pressed = pygame.key.get_pressed()
if pressed[K_UP]:
myogre.speed = 4.0
else:
myogre.speed = 0.0
# Update:
AllSprites.update()
for spr1 in Stats:
for spr2 in [myogre]:
if spr1 != spr2:
if pygame.Rect.colliderect(spr1.collisionRect,
spr2.collisionRect):
#spr1.backup()
spr2.backup()
# Draw everything:
screen.blit(background, (0, 0))
red = pygame.Color("red")
pygame.draw.rect(screen, red, myogre.rect, 1)
pygame.draw.rect(screen, red, myogre.collisionRect, 1)
for spr in Stats:
pygame.draw.rect(screen, red, spr.collisionRect, 1)
AllSprites.draw(screen)
pygame.display.flip()
def __init__(self, screen, site):
self.screen = screen
self.site = site
self.imagemanager = ImageManager()
