def on_draw(self):
self.clear()
h = list(self.highlight)
if self.highlight_cursor:
h.append(self.highlight_cursor)
self.terrain.draw(highlight=h, mode=self.render_mode)
drawing.circle(self.player.shape.x, self.player.shape.y, self.player.shape.radius, num=8)
drawing.circle(self.brush.x, self.brush.y, self.brush.radius, num=32)
# self.debug_label.draw()
self.fps_display.draw()
def on_draw(self):
self.clear()
h = list(self.highlight)
if self.highlight_cursor:
h.append(self.highlight_cursor)
self.terrain.draw(highlight=h, mode=self.render_mode)
drawing.circle(self.player.shape.x,
self.player.shape.y,
self.player.shape.radius,
num=8)
drawing.circle(self.brush.x, self.brush.y, self.brush.radius, num=32)
# self.debug_label.draw()
self.fps_display.draw()
def draw(self, image, cellmap, is_cell, simulation_config):
"""Draws the cell by adding the given value to the image."""
if self._needs_refresh:
self._refresh()
#Diffraction pattern currently only applies to graySynthetic image
image_type = simulation_config["image.type"]
background_color = simulation_config["background.color"]
cell_color = simulation_config["cell.color"]
top = self._region.top
bottom = self._region.bottom
left = self._region.left
right = self._region.right
width = right - left
height = bottom - top
mask = np.zeros((height, width), dtype=np.bool)
body_mask = polygon(
r=(self._head_left.y - top, self._head_right.y - top,
self._tail_right.y - top, self._tail_left.y - top),
c=(self._head_left.x - left, self._head_right.x - left,
self._tail_right.x - left, self._tail_left.x - left),
shape=mask.shape)
body_mask_up = polygon(
r=(self._head_left.y - self._region.top,
ceil((self._head_right.y + self._head_left.y) / 2) -
self._region.top,
ceil((self._tail_right.y + self._tail_left.y) / 2) -
self._region.top, self._tail_left.y - self._region.top),
c=(self._head_left.x - self._region.left,
ceil((self._head_right.x + self._head_left.x) / 2) -
self._region.left,
ceil((self._tail_right.x + self._tail_left.x) / 2) -
self._region.left, self._tail_left.x - self._region.left),
shape=mask.shape)
body_mask_middle = polygon(
r=(ceil((self._head_right.y + self._head_left.y * 2) / 3) -
self._region.top,
ceil((self._head_right.y * 2 + self._head_left.y) / 3) -
self._region.top,
ceil((self._tail_right.y * 2 + self._tail_left.y) / 3) -
self._region.top,
ceil((self._tail_right.y + self._tail_left.y * 2) / 3) -
self._region.top),
c=(ceil((self._head_right.x + self._head_left.x * 2) / 3) -
self._region.left,
ceil((self._head_right.x * 2 + self._head_left.x) / 3) -
self._region.left,
ceil((self._tail_right.x * 2 + self._tail_left.x) / 3) -
self._region.left,
ceil((self._tail_right.x + self._tail_left.x * 2) / 3) -
self._region.left),
shape=mask.shape)
head_mask = circle(x=self._head_center.x - left,
y=self._head_center.y - top,
radius=self._width / 2,
shape=mask.shape)
tail_mask = circle(x=self._tail_center.x - left,
y=self._tail_center.y - top,
radius=self._width / 2,
shape=mask.shape)
#phaseContrast unchanged
if image_type == "phaseContrast":
if not is_cell:
mask[body_mask] = True
mask[head_mask] = True
mask[tail_mask] = True
image[self._region.top:self._region.bottom, self._region.
left:self._region.right][mask] = 0.39 # 0.39*255=100
else:
mask = np.zeros((height, width), dtype=np.bool)
mask[body_mask] = True
image[self._region.top:self._region.bottom, self._region.
left:self._region.right][mask] = 0.25 # 0.25*255=65
mask = np.zeros((height, width), dtype=np.bool)
mask[head_mask] = True
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] = 0.25
mask = np.zeros((height, width), dtype=np.bool)
mask[tail_mask] = True
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] = 0.25
mask = np.zeros((height, width), dtype=np.bool)
mask[body_mask_up] = True
image[self._region.top:self._region.bottom, self._region.
left:self._region.right][mask] = 0.63 # 0.63*255=160
mask = np.zeros((height, width), dtype=np.bool)
mask[body_mask_middle] = True
image[self._region.top:self._region.bottom, self._region.
left:self._region.right][mask] = 0.39 # 0.39*255=100
elif image_type == "graySynthetic":
mask[body_mask] = True
mask[head_mask] = True
mask[tail_mask] = True
gaussian_filter_truncate = simulation_config[
"light.diffraction.truncate"]
gaussian_filter_sigma = simulation_config[
"light.diffraction.sigma"]
diffraction_strength = simulation_config[
"light.diffraction.strength"]
cell_opacity = self._opacity if self._opacity != "auto" and self._opacity != "None" else simulation_config[
"cell.opacity"]
#in order to use optimze funtion
gaussian_filter_sigma = max(gaussian_filter_sigma, 0)
extension = ceil(gaussian_filter_truncate * gaussian_filter_sigma -
0.5)
diff_top = top - (2 * extension)
diff_left = left - (2 * extension)
diff_bottom = bottom + (2 * extension)
diff_right = right + (2 * extension)
rendering_top = top - extension
rendering_left = left - extension
rendering_bottom = bottom + extension
rendering_right = right + extension
re_diff_top, re_diff_left, re_rendering_top, re_rendering_left = [
max(i, 0)
for i in [diff_top, diff_left, rendering_top, rendering_left]
]
re_diff_bottom, re_rendering_bottom = [
min(i, image.shape[0])
for i in [diff_bottom, rendering_bottom]
]
re_diff_right, re_rendering_right = [
min(i, image.shape[1]) for i in [diff_right, rendering_right]
]
if is_cell:
cellmap[top:bottom, left:right][mask] += 1
cellmap_diff = cellmap[re_diff_top:re_diff_bottom,
re_diff_left:re_diff_right]
diffraction_mask = np.zeros(cellmap_diff.shape, dtype=float)
diffraction_mask[cellmap_diff > 0] = diffraction_strength
diffraction_mask = gaussian_filter(
diffraction_mask,
gaussian_filter_sigma,
truncate=gaussian_filter_truncate)
diffraction_mask[cellmap_diff == 0] += background_color
diffraction_mask[
cellmap_diff >
0] = cell_color + cell_opacity * diffraction_mask[
cellmap_diff > 0]
#print("diffraction mask shape: ", diffraction_mask.shape)
image[re_rendering_top:re_rendering_bottom,
re_rendering_left:re_rendering_right] = diffraction_mask[
re_rendering_top - re_diff_top:re_rendering_bottom -
re_diff_bottom if re_rendering_bottom -
re_diff_bottom != 0 else None,
re_rendering_left - re_diff_left:re_rendering_right -
re_diff_right if re_rendering_right -
re_diff_right != 0 else None]
else:
cellmap[top:bottom, left:right][mask] -= 1
cellmap_diff = cellmap[re_diff_top:re_diff_bottom,
re_diff_left:re_diff_right]
diffraction_mask = np.zeros(cellmap_diff.shape, dtype=float)
diffraction_mask[cellmap_diff > 0] = diffraction_strength
diffraction_mask = gaussian_filter(
diffraction_mask,
gaussian_filter_sigma,
truncate=gaussian_filter_truncate)
diffraction_mask[cellmap_diff == 0] += background_color
diffraction_mask[
cellmap_diff >
0] = cell_color + cell_opacity * diffraction_mask[
cellmap_diff > 0]
#print("diffraction mask shape: ", diffraction_mask.shape)
image[re_rendering_top:re_rendering_bottom,
re_rendering_left:re_rendering_right] = diffraction_mask[
re_rendering_top - re_diff_top:re_rendering_bottom -
re_diff_bottom if re_rendering_bottom -
re_diff_bottom != 0 else None,
re_rendering_left - re_diff_left:re_rendering_right -
re_diff_right if re_rendering_right -
re_diff_right != 0 else None]
elif image_type == "binary":
mask[body_mask] = True
mask[head_mask] = True
mask[tail_mask] = True
if is_cell:
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] += 1.0
cellmap[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] += 1
else:
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] -= 1.0
cellmap[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] -= 1
def draw(self, image, is_cell, greySyntheticImage, phaseContractImage):
"""Draws the cell by adding the given value to the image."""
if self._needs_refresh:
self._refresh()
# binary images (not grey scale) don't have diffraction pattern
# currently also no diffraction pattern for PCImg
if (not greySyntheticImage) or phaseContractImage:
self._sigma = 0
self._diff_v = 0
# calculate the expansion of the region based on how much does diffraction pattern spread
# if self._sigma = 0, then expansion = 0
# if self._diff_v = 0, then expansion = 0
# if phaseContractImage is True, then expansion = 0
expansion = int(self._sigma * 2) if self._diff_v != 0 else 0
# expand the square enclosing the cell
top = self._region.top - expansion
bottom = self._region.bottom + expansion
left = self._region.left - expansion
right = self._region.right + expansion
width = right - left
height = bottom - top
mask = np.zeros((height, width), dtype=np.bool)
# use an extra mask for diffraction pattern
diff_mask = np.zeros((height, width), dtype=np.float)
# body_mask is expanded
body_mask = polygon(
r=(self._head_left.y - top, self._head_right.y - top,
self._tail_right.y - top, self._tail_left.y - top),
c=(self._head_left.x - left, self._head_right.x - left,
self._tail_right.x - left, self._tail_left.x - left),
shape=mask.shape)
# body_mask_up is for phaseContractImage so no change for now
body_mask_up = polygon(
r=(self._head_left.y - self._region.top,
ceil((self._head_right.y + self._head_left.y) / 2) -
self._region.top,
ceil((self._tail_right.y + self._tail_left.y) / 2) -
self._region.top, self._tail_left.y - self._region.top),
c=(self._head_left.x - self._region.left,
ceil((self._head_right.x + self._head_left.x) / 2) -
self._region.left,
ceil((self._tail_right.x + self._tail_left.x) / 2) -
self._region.left, self._tail_left.x - self._region.left),
shape=mask.shape)
# body_mask_middle is for phaseContractImage so no change for now
body_mask_middle = polygon(
r=(ceil((self._head_right.y + self._head_left.y * 2) / 3) -
self._region.top,
ceil((self._head_right.y * 2 + self._head_left.y) / 3) -
self._region.top,
ceil((self._tail_right.y * 2 + self._tail_left.y) / 3) -
self._region.top,
ceil((self._tail_right.y + self._tail_left.y * 2) / 3) -
self._region.top),
c=(ceil((self._head_right.x + self._head_left.x * 2) / 3) -
self._region.left,
ceil((self._head_right.x * 2 + self._head_left.x) / 3) -
self._region.left,
ceil((self._tail_right.x * 2 + self._tail_left.x) / 3) -
self._region.left,
ceil((self._tail_right.x + self._tail_left.x * 2) / 3) -
self._region.left),
shape=mask.shape)
# head_mask is expanded
head_mask = circle(x=self._head_center.x - left,
y=self._head_center.y - top,
radius=self._width / 2,
shape=mask.shape)
# tail_mask is expanded
tail_mask = circle(x=self._tail_center.x - left,
y=self._tail_center.y - top,
radius=self._width / 2,
shape=mask.shape)
if greySyntheticImage:
# phaseContractImage == True part remains unchanged
if phaseContractImage:
if not is_cell:
mask[body_mask] = True
mask[head_mask] = True
mask[tail_mask] = True
image[self._region.top:self._region.bottom, self._region.
left:self._region.right][mask] = 0.39 # 0.39*255=100
else:
mask = np.zeros((height, width), dtype=np.bool)
mask[body_mask] = True
image[self._region.top:self._region.bottom, self._region.
left:self._region.right][mask] = 0.25 # 0.25*255=65
mask = np.zeros((height, width), dtype=np.bool)
mask[head_mask] = True
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] = 0.25
mask = np.zeros((height, width), dtype=np.bool)
mask[tail_mask] = True
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] = 0.25
mask = np.zeros((height, width), dtype=np.bool)
mask[body_mask_up] = True
image[self._region.top:self._region.bottom, self._region.
left:self._region.right][mask] = 0.63 # 0.63*255=160
mask = np.zeros((height, width), dtype=np.bool)
mask[body_mask_middle] = True
image[self._region.top:self._region.bottom, self._region.
left:self._region.right][mask] = 0.39 # 0.39*255=100
if not phaseContractImage:
mask[body_mask] = True
mask[head_mask] = True
mask[tail_mask] = True
if is_cell:
if (self._diff_v != 0) and (self._sigma != 0):
diff_mask[body_mask] = self._diff_v
diff_mask[head_mask] = self._diff_v
diff_mask[tail_mask] = self._diff_v
# blur the white cell
diff_mask = gaussian(diff_mask, self._sigma)
# add diffraction pattern to the image
image[top:bottom, left:right] += diff_mask
# overlap the cell part with the black cell
image[top:bottom,
left:right][mask] = 0.15 #0.39 - 0.24 = 0.15
else:
if (self._diff_v != 0) and (self._sigma != 0):
diff_mask[body_mask] = self._diff_v
diff_mask[head_mask] = self._diff_v
diff_mask[tail_mask] = self._diff_v
# blur the white cell
diff_mask = gaussian(diff_mask, self._sigma)
# subtract diffraction pattern to the image
image[top:bottom, left:right] -= diff_mask
# overlap the cell part with background
image[top:bottom, left:right][mask] = 0.39
else:
mask[body_mask] = True
mask[head_mask] = True
mask[tail_mask] = True
if is_cell:
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] += 1.0
else:
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] += -1.0
def draw(self, image, is_cell, greySyntheticImage, phaseContractImage):
"""Draws the cell by adding the given value to the image."""
if self._needs_refresh:
self._refresh()
width = self._region.right - self._region.left
height = self._region.bottom - self._region.top
mask = np.zeros((height, width), dtype=np.bool)
body_mask = polygon(
r=(self._head_left.y - self._region.top,
self._head_right.y - self._region.top,
self._tail_right.y - self._region.top,
self._tail_left.y - self._region.top),
c=(self._head_left.x - self._region.left,
self._head_right.x - self._region.left,
self._tail_right.x - self._region.left,
self._tail_left.x - self._region.left),
shape=mask.shape)
body_mask_up = polygon(
r=(self._head_left.y - self._region.top,
ceil((self._head_right.y + self._head_left.y) / 2) - self._region.top,
ceil((self._tail_right.y + self._tail_left.y) / 2) - self._region.top,
self._tail_left.y - self._region.top),
c=(self._head_left.x - self._region.left,
ceil((self._head_right.x + self._head_left.x) / 2) - self._region.left,
ceil((self._tail_right.x + self._tail_left.x) / 2) - self._region.left,
self._tail_left.x - self._region.left),
shape=mask.shape)
body_mask_middle = polygon(
r=(ceil((self._head_right.y + self._head_left.y * 2) / 3) - self._region.top,
ceil((self._head_right.y * 2 + self._head_left.y) / 3) - self._region.top,
ceil((self._tail_right.y * 2 + self._tail_left.y) / 3) - self._region.top,
ceil((self._tail_right.y + self._tail_left.y * 2) / 3) - self._region.top),
c=(ceil((self._head_right.x + self._head_left.x * 2) / 3) - self._region.left,
ceil((self._head_right.x * 2 + self._head_left.x) / 3) - self._region.left,
ceil((self._tail_right.x * 2 + self._tail_left.x) / 3) - self._region.left,
ceil((self._tail_right.x + self._tail_left.x * 2) / 3) - self._region.left),
shape=mask.shape)
head_mask = circle(
x=self._head_center.x - self._region.left,
y=self._head_center.y - self._region.top,
radius=self._width / 2,
shape=mask.shape)
tail_mask = circle(
x=self._tail_center.x - self._region.left,
y=self._tail_center.y - self._region.top,
radius=self._width / 2,
shape=mask.shape)
if greySyntheticImage:
if phaseContractImage:
if not is_cell:
mask[body_mask] = True
mask[head_mask] = True
mask[tail_mask] = True
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] = 0.39 # 0.39*255=100
else:
mask = np.zeros((height, width), dtype=np.bool)
mask[body_mask] = True
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] = 0.25 # 0.25*255=65
mask = np.zeros((height, width), dtype=np.bool)
mask[head_mask] = True
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] = 0.25
mask = np.zeros((height, width), dtype=np.bool)
mask[tail_mask] = True
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] = 0.25
mask = np.zeros((height, width), dtype=np.bool)
mask[body_mask_up] = True
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] = 0.63 # 0.63*255=160
mask = np.zeros((height, width), dtype=np.bool)
mask[body_mask_middle] = True
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] = 0.39 # 0.39*255=100
if not phaseContractImage:
mask[body_mask] = True
mask[head_mask] = True
mask[tail_mask] = True
if is_cell:
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] += -0.24
else:
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] += 0.24
else:
mask[body_mask] = True
mask[head_mask] = True
mask[tail_mask] = True
if is_cell:
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] += 1.0
else:
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] += -1.0
def draw(self, image, cellmap, is_cell, simulation_config):
"""Draws the cell by adding the given value to the image."""
if self._needs_refresh:
self._refresh()
#Diffraction pattern currently only applies to graySynthetic image
image_type = simulation_config["image.type"]
background_color = simulation_config["background.color"]
cell_color = simulation_config["cell.color"]
top = self._region.top
bottom = self._region.bottom
left = self._region.left
right = self._region.right
width = right - left
height = bottom - top
mask = np.zeros((height, width), dtype=np.bool)
body_mask = polygon(
r=(self._head_left.y - top,
self._head_right.y - top,
self._tail_right.y - top,
self._tail_left.y - top),
c=(self._head_left.x - left,
self._head_right.x - left,
self._tail_right.x - left,
self._tail_left.x - left),
shape=mask.shape)
body_mask_up = polygon(
r=(self._head_left.y - self._region.top,
ceil((self._head_right.y + self._head_left.y) / 2) - self._region.top,
ceil((self._tail_right.y + self._tail_left.y) / 2) - self._region.top,
self._tail_left.y - self._region.top),
c=(self._head_left.x - self._region.left,
ceil((self._head_right.x + self._head_left.x) / 2) - self._region.left,
ceil((self._tail_right.x + self._tail_left.x) / 2) - self._region.left,
self._tail_left.x - self._region.left),
shape=mask.shape)
body_mask_middle = polygon(
r=(ceil((self._head_right.y + self._head_left.y * 2) / 3) - self._region.top,
ceil((self._head_right.y * 2 + self._head_left.y) / 3) - self._region.top,
ceil((self._tail_right.y * 2 + self._tail_left.y) / 3) - self._region.top,
ceil((self._tail_right.y + self._tail_left.y * 2) / 3) - self._region.top),
c=(ceil((self._head_right.x + self._head_left.x * 2) / 3) - self._region.left,
ceil((self._head_right.x * 2 + self._head_left.x) / 3) - self._region.left,
ceil((self._tail_right.x * 2 + self._tail_left.x) / 3) - self._region.left,
ceil((self._tail_right.x + self._tail_left.x * 2) / 3) - self._region.left),
shape=mask.shape)
head_mask = circle(
x=self._head_center.x - left,
y=self._head_center.y - top,
radius=self._width / 2,
shape=mask.shape)
tail_mask = circle(
x=self._tail_center.x - left,
y=self._tail_center.y - top,
radius=self._width / 2,
shape=mask.shape)
#phaseContrast unchanged
if image_type == "phaseContrast":
if not is_cell:
mask[body_mask] = True
mask[head_mask] = True
mask[tail_mask] = True
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] = 0.39 # 0.39*255=100
else:
mask = np.zeros((height, width), dtype=np.bool)
mask[body_mask] = True
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] = 0.25 # 0.25*255=65
mask = np.zeros((height, width), dtype=np.bool)
mask[head_mask] = True
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] = 0.25
mask = np.zeros((height, width), dtype=np.bool)
mask[tail_mask] = True
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] = 0.25
mask = np.zeros((height, width), dtype=np.bool)
mask[body_mask_up] = True
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] = 0.63 # 0.63*255=160
mask = np.zeros((height, width), dtype=np.bool)
mask[body_mask_middle] = True
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] = 0.39 # 0.39*255=100
elif image_type == "graySynthetic":
mask[body_mask] = True
mask[head_mask] = True
mask[tail_mask] = True
gaussian_filter_truncate = simulation_config["light.diffraction.truncate"]
gaussian_filter_sigma = simulation_config["light.diffraction.sigma"]
diffraction_strength = simulation_config["light.diffraction.strength"]
#in order to use optimze funtion
extension = max(floor(gaussian_filter_truncate * gaussian_filter_sigma - 0.5),0)
diffraction_mask = mask.astype(float)
diffraction_mask[mask] = diffraction_strength
diffraction_mask = np.pad(diffraction_mask, extension, mode="constant")
diffraction_mask = gaussian_filter(diffraction_mask, gaussian_filter_sigma, truncate = gaussian_filter_truncate)
diff_top = top - extension
diff_left = left - extension
diff_bottom = bottom + extension
diff_right = right + extension
if is_cell:
cellmap[top:bottom, left:right][mask] += 1
cellmap_diff = cellmap[diff_top:diff_bottom, diff_left:diff_right]
diffraction_mask = np.zeros(cellmap_diff.shape, dtype=float)
diffraction_mask[cellmap_diff>0] = diffraction_strength
diffraction_mask = gaussian_filter(diffraction_mask, gaussian_filter_sigma, truncate = gaussian_filter_truncate)
diffraction_mask[cellmap_diff==0] += background_color
image[diff_top:diff_bottom, diff_left:diff_right] = diffraction_mask
else:
cellmap[top:bottom, left:right][mask] -= 1
cellmap_diff = cellmap[diff_top:diff_bottom, diff_left:diff_right]
diffraction_mask = np.zeros(cellmap_diff.shape, dtype=float)
diffraction_mask[cellmap_diff>0] = diffraction_strength
diffraction_mask = gaussian_filter(diffraction_mask, gaussian_filter_sigma, truncate = gaussian_filter_truncate)
diffraction_mask[cellmap_diff==0] += background_color
image[diff_top:diff_bottom, diff_left:diff_right] = diffraction_mask
elif image_type == "binary":
mask[body_mask] = True
mask[head_mask] = True
mask[tail_mask] = True
if is_cell:
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] += 1.0
cellmap[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] += 1
else:
image[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] -= 1.0
cellmap[self._region.top:self._region.bottom,
self._region.left:self._region.right][mask] -= 1